GameMaker: Coins, floating text, basic shop

Let's just say that art assets for this example are from abstract collection.

While I have made this example a long time ago, it appears that questions about such still are common, and thus it would make sense to give it a 'searchable form' of post here.
This example demonstrates creation of 3 things:

• Coins, as a basic collectable item<./li>
• Floating text, which is used here to display '+1' on picking up a coin, but has many other uses.
• Shops, as objects that sell you useful (or here, useless) things for coins.

Overall, rather simplistic, however still useful for ones that do not know what they're doing with these.

Download

LDLS

As you might have noticed (or most likely haven't), a new item labelled 'LDLS' appeared in navigation menu on the right. That is a project that I've been working on for a fair amount of time now.

Printing text, and a 40-bit variable

LDLS is an "IDE" for specific assembly-like programming language, which is used in my university for studying how low-level operations (as, multiplication, floating point operations, or command buffer) work. Previous version of program was also developed by students of university, however that was, well, 18 years ago. And it wasn't too good or stable after all, which served as primary motivation to writing my own version.
This brings language additions that weren't around in original version, as dynamic variable creation, variable labels (original allowed only up to 40 'nameless' registers and up to 256x32bit memory), nearly no variable limit (core class takes up fair part of project, but allows you to do operations over variables of length limited only by your RAM), call stack, offset-based address for jumps, and even extensions, which allow to expand it's original scope of use a bit.
Program itself contains code editor, compiler (builds fairly compact byte code, removing all unnecessary data), runner, and debugger (step-by-step debugging and watching variables), and a manual.
Overall, quite interesting, but complicated, unless you know program's language.

GameMaker: Taking screenshot of area larger than screen

Above: in-game view. Below: taken screenshot of entire room

This is an example that I've actually made a long time ago, but apparently it remains a common unresolved problem.
For multiple cases you may need to take a screenshot (or copy to surface) entire room, while only portion of it can be seen at once (window/screen size limitations).
A perfect work-around for this is to force screen drawing into a surface of chosen size, after adjusting view settings.

Download

GameMaker: 'strategy' unit selection

Today I've made a simple example for strategy-like unit selection.
That is, selecting units (instances) with mouse, with selection rectangle and selected units being displayed accordingly.
Example is well-commented and should be easy to use.
Principle of work is simple - to detect units that overlap selection rectangle, game should cycle through them, performing collision_rectangle checks. Amount of calculations and code complexity is cut here by local variable usage (if you did not know, local variables 'var' will be available inside of with constructions without any prefixes).

Download

Design: Dreemchest

(or see here)

Today I've made a really simple design for manual site for project called Dreemchest, which is a open-source game development tool, supporting Lua and C++, which is currently in development.
Things got done with some simple CSS, and (from my point of view) look somewhat nicer than strictly 'plain text' current design.

Also I'm having a feeling that I use #000000 + #f0f0f0 + #f7f7f7 + #ffffff color combination a bit too often when working with websites.

About, '10fastfingers'

Today, a chat at one of Russian GameMaker forums has came to questions, if 200 symbols per minute are enough of typing speed, and how many people satisfy this condition.
After a brief search, website 10fastfingers has been found.
One allows user to take a test of typing random words in their language of choice, measuring their speed, strokes per minute, and allowing to compare that to other people. Also 'contests' (same text typed by different users with local leaderboard), profiles, and other cool features.
After doing few tests alone and with other people (which have figured that I'm typing at ~80 words per minute average for both English and Russian), someone have pointed out that input field accepts copy&paste strokes, and, as fact, counts them as 'legit' input, only requiring Space key to be pressed by user to move on to next word.
Some minutes later, and two unsuccessful attempts to ask internet about event flow in JavaScript, I wrote the following code, executing which works as a single-step injection to add 'auto-completition' of words, allowing maximum speed of about 300 words per minute to be reached by simply tapping Space:

var inp = document.getElementById('inputfield'),
    row = document.getElementById('row1');
inp.onkeydown = function(e) {
    if (e.keyCode == 32)
    setTimeout(function() {
        for (var n = row.childNodes, e, i = 0; i < n.length; i++)
        if (n[i].className == 'highlight') inp.innerText = n[i].innerText
    }, 150)
}

(to avoid negative results for the site, a single name in above code is changed, disabling it. guess which)
From what can be seen from my profile there, a peak of 193 word per minute 'pops' out of normal 80WPM rates, which would be quite enough of proof, while not being too bashing.
As a related note, some people have came surprisingly close to that rate, even providing video proofs.

From JavaScript point of view, not a lot can be done to fully prevent cheating, however minifying code and adding few additional checks to verify that keys are actually being typed would reduce probability of such events to occur easily.

Games via VCL

Are we living in those times when games with 2x scaled pixel-art are cool?

Lately I've been helping out someone with their university coursework, which happens to be about writing interactive application with C++ & VCL.
By task game has to be about growing vegetables, and should utilize use of classes heavily.
In this case that means that every tile type is presented by a separate class with multi-level inheritance and overridable methods.
My 'part' here is mainly graphics, making difference to 'button-based' works of this level.

VCL itself is apparently targeting mainly applications development, leaving such activity as calculating rotated image data or scaling images to per-pixel work of programmer, thus making it less likely for games to be made with it. Thought that doesn't mean that you can't make simple and nice-looking games with it.

On screenshot, you can see semi-grown pixely tomatoes (small red & orange things near center of image), similarly semi-grown melon (larger yellowish square), grass (which makes crops grow slower, if grow at all), and different levels of irrigation on tiles. In the middle of screenshot you can see 4 wells, which water surrounding areas over time, and two spherical things, which for mysterious reasons burn out nearby grass at random intervals of time (principle of their work is yet to be thought of and written down in the instructions to game).

Overall, this wouldn't be a large project, but still interesting to work on.

Minecraft: Shattered world (r1)

"Overview" screenshot.

This day was spent by me in working with JavaScript and Lua.
JavaScript works did not get a great visual presentation this time, but upcoming Lua framework for manipulating WorldEdit in minecraft did.

View "from inside"

My new script generates a very specific sort of world for Minecraft - such world looks just about how it would (probably) look after impact with large-sized asteroid, dealing huge amounts of destruction and sending some parts of land to low orbit.
That's the idea. Generator creates blocks of many kinds according to specific pattern, paying attention to multiple factors, granting uneven distribution of materials and separate concentrated 'islands' which attract surrounding blocks to them.
Such maps have value as an uncommon survival challenge.
Overall, this was quite fun for me; I plan to experiment with generation even further, which may eventually result in a server-sided plugin of this purpose.

You can download the map (savegame) here: (420kb .zip)