I felt like drawing something that would remind me of the song Mr. Spaceman

Click for bigger version.

This:

I have the same problem as Machine. I know I've seen this before and I pretty sure it was in a movie. Where is this from?

I created something from an old unfinished Glorious Trainwreck.

Not sure what it is or how to turn it into a game quite yet.

That was strangely - but pleasantly - mesmerizing. And disorienting. The room is still spinning.

EDIT: Another!

Today
Yesterday
A couple days before

"Hello, world!"

Code:

">+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.>>>++++++++[<++++>-]<.>>>++++++++++[<+++++++++>-]<---.<<<<.+++.------.--------.>>+.#
"Please wait, this may take a while :P
~;s~j[16]><+-.,[0]#[223]^[1]}[6]N[26]i[15]j[172]}[7]N"d[15]j[172]}[8]
N-#[15]*i[0]j[172]}[9]N8#[15]5d[0]j[172]}[10]NH#[15]@)[0]~s,;~j[172]}[11]
NX~\'[1]~#[15]U([0]j[172]}[12]N[132]#[15]`}[0]4[0]N[172]4[1]<[194]4[0]}[194]
=[172]i[17]#[17]u^[0]}[12]N[0]4[0]}[194]d[17]=[172]#[17][152]^[0]}[12]N[159]
d[194]}[13]N[140]i[194]j[140]}[14]N[172]_i[17]>[17]5[255]N[183]#
[192][17]5[221]N[16]#[193][17]j[16][222][254]

BrainF*ck interpreter GET.

I added labels. Some things are much easier now. Also a handful of bugfixes.

I need to get work on my AGBIC entry 

I fixed a major bug regarding parsing source with comments. Redownload if you please.

M-Code shall be its name.

There are 3 variations - 8 bit, 16 bit, and 32 bit. Read the readme for the differences, read reference.txt for the complete command set. Post any questions here if it's hard to understand and I'll do my best to clarify. Please note that it's not verified to be 100% bug free.

Download

Two fully functional programs. Every character is 1 byte, numbers enclosed in brackets are single bytes. I think I'll also make a second parser using shorts for numbers as opposed to bytes because a mere 256 bytes of program memory isn't terribly much and may keep it from being turing-complete.

And I need a name! 

Hello, world!

Code:

// Program execution starts at 0. //

>[64] // Store 45 in register A from memory address 64 to frequently be used as a constant. //
j[8] // Jump to memory address 8 //


$8 // This tells the parser that the following code is intended to start at memory address 8. //
}[32] // Push "H" into register B from address 32. //
. // Add "H" from B to the end of the memory string. //
i[9] // Increment the 32 in }[32] by one, so next loop it'll push "e", then "l", (...) //
}[9] // Push that same number into B to get ready for a comparison. //
?[8] // Jump back to $8 to create a loop if the value in register A is > B to know if we've reached the end of "Hello, world!". //

; // After the above loops has finished, ; prints the accumulated string to the console. //
_ // Terminate program execution. //

$32 // Set the memory address to 32. //
// Whitespace is not recognized by the parser, [32] is the ASCII code for a space. //
Hello,[32]world!

$64 // Set the address to 64. //
[45] // This is for indicating where the "!" in "Hello, world!" is located. //

Fibonacci sequence

Code:

// Program execution starts at 0. //

>[64] 1;s // Store 0 in register A and print it to the console. //
>[65] 1;s // Store 1 in A and print it. //
j[16] // Jump to memory address 16. //

$16 // Set address to 16. This is our main loop start. //

d[66] // Decrement the value at memory address 66 (15) by one. //
>[66] // Push that value into register A. //
b // Set register B to equal 0. //
=[96] // If A = B (A = 0) jump to memory address 96, where a program termination command is located. //

>[64] // Push the first value into A. //
}[65] // Push the second into B. //
+ // Add the first and second values (A+B) and put the result in register C. //
3;s // Print the resulting sum to the console. //
([68] // Pop the result into memory address 68. //
#[65][64] // Shift the second number into where the first was. //
#[68][65] // Shift the new resulting number into where the second was. //

j[16] // Jump back to the loop's start at address 16. //

$64 // Set address to 64, these memory addresses are used as variables in calculation. //
[0][1] // First value of Fibonacci sequence starts as 0, second starts as 1. //
[15] // Number of iterations (n-1) of the sequence to go through. //

$96 // Set address to 96. //
_ // Program termination command. //

Just a couple quick things and I'll make a download.

Just need to make sure I haven't got any bugs going on, then I'll put it up for download.

What should I call it? I've gt not idea what to name it. Preferably something with "TIG" somehow in its title 

Final command set:

Code:

Push, pop for the A, B, C registers
> <
} {
) (

Handle the string in memory by printing it, getting it from input, and swapping it with a second memory string
; \ ~

Clear the string in memory
s

Read characters from the memory string and put them in the A, B, C registers
^ ` '

Write characters to the end of the memory string from the A, B, C registers
: . ,

Output the numerical value onto the end of the memory string
1 2 3

Copy a byte in memory from one place to another
#

Increment, decrement a byte in memory
i d

increment, decrement the value in the A, B, C registers
h g
u t
e d

Jump unconditionally
j

Jump if A > B
?

Jump if A < B
!

Jump if A = B
=

Swap A and B registers
x

Swap B and C registers
y

Swap C and A registers
z

Set a register to 0
a b c

Perform a logical NOT operation on registers A, B, C
A B C

Copy the value in the A register into both B and C
\

Perform an operation on A and B and place the result in C
Add: +
Subtract: -
Divide: /
Multiply: *
Modulo: %
Raise to power: v
Bit shift left: l
Bit shift right:r

Kill program
_

Comment
// (...) //

EDIT: newly added some logical operators and more bitshifting.



EDIT: Hurrah! A functional Hello World program!

Code:

>[64]j[8]
$8
}[32].i[9]}[9]?[8]
;n_
$32
Hello,[32]world!
$64
[45]

EDIT: But now the parser is screwing up on my Fibonacci number calculation. :/

EDIT: Fibonacci sequence GO!

Code:

>[64]1;s>[65]1;sj[16]
$16
d[66]>[66]b=[96]
>[64]}[65]+3;s
([68]#[65][64]#[68][65]
j[16]
$64
[0][1]
[15]
$96
_

So I'm settled, I guess. It'll have access to its own source (which will be placed in its memory bank and execution starts at 0)

Here's what I expect the code to look like.

Code:

#[48] //attribute 48 bytes to program memory//


$[32] //jump to position 32 in memory//
Hello,[32]world! //Whitespace isn't recognized by the parser. [32] is the ASCII code for a space.//


$[2]

[44]
>[2] //push a constant 44 into the first accumulator//

}[32] //push the memory at address 32 into the second accumulator//
^ //print the character in the second accumulator to the console//
+[4] //increment that previous 32 by 1//
}[4] //push the value into the second accumulator//

S[5] //jump to 5 only if the accumulator A is greater than the accumulator B//

@ //end the program//

That would output "Hello, world!" to the console.

Except it does need some tweaking.



EDIT: A more refined command library:

Code:

Push, pop, output, input for the A, B, and C registers
> < ^ :
} { ` .
) ( ' ,

Output a newline character
;

Copy a byte in memory from one place to another
#

Increment, decrement a byte in memory
i d

Jump unconditionally
j

Jump if A < B
!

Jump if A > B
?

Swap A and B registers
x

Swap B and C registers
y

Swap C and A registers
z

Set a register to 0
a b c

Perform an operation on A and B and place the result in C
Divide: /
Multiply: *
Add: +
Subtract: -
Modulo: %
Raise to power: v
Compare equal: =

Kill program
_

Comment
// (...) //

and what a hello world program would look like now (uncommented)

Code:

>[48]
}[32]^+[5]}[5]?[2]_
$32
Hello,[32]world!
$48
[44]

EDIT: Further refined, likely final:

Code:

Push, pop for the A, B, C registers
> <
} {
) (

Handle the string in memory by printing it, getting it from input, and swapping it with a second memory string
; : ~

Clear the string in memory
s

Print a newline
n

Read characters from the memory string and put them in the A, B, C registers
^ ` '

Write characters to the end of the memory string from the A, B, C registers
: . ,

Copy a byte in memory from one place to another
#

Increment, decrement a byte in memory
i d

Jump unconditionally
j

Jump if A < B
!

Jump if A > B
?

Swap A and B registers
x

Swap B and C registers
y

Swap C and A registers
z

Set a register to 0
a b c

Perform a logical NOT operation on registers A, B, C
A B C

Copy the value in the A register into both B and C
~

Perform an operation on A and B and place the result in C
Divide: /
Multiply: *
Add: +
Subtract: -
Modulo: %
Raise to power: v
Compare equal: =

Kill program
_

Comment
// (...) //

I don't really want to do a joke language 

TigScript

Use game references to do commands.

Out of curiosity, what are you using/ what method are you using that makes them so easy to make?

The fact that I've literally made somewhere between 10 and 20 complete or almost complete parsers means I've got a library of commands I've written and refined over heavy use to make it very fast and painless. But parsing something with single-character commands like BrainF-ck is extraordinarily easy in the first place.

An esoteric program language is one that's supposed to be impractical and stupid, but still fun and usually an absurd challenge to use. I've made several in the past but didn't think they were unique enough to make public. I'm in the mood again, and making them is extremely fast, so I need suggestions for something interesting.

Esoteric languages wiki

EDIT:

http://esoteric.voxelperfect.net/wiki/M-code

Download

Batman Begins film score on Pandora. I plugged in John Williams and it gives me a lot of nice orchestrated music, most of them unsurprisingly being film scores.

To be honest, this doesn't look all that interesting to me.
Top-down shooters always appear boring to me unless they're with vehicles instead of people. Something about the perspective just makes it completely dull for my brain; I feel like humans weren't meant to be viewed from that angle, and that taints the rest of the whole experience so it just doesn't amuse me at all.

I understand what you mean; often they don't engage me. But for me, co-op can sell just about anything (even if this didn't look more interesting than your typical top-down).

Seconded. If not for the co-op, I'd be uninterested, too.

How do these games that would take me a day or two to make myself end up making their developers more money in one deal than I make over the entire summer as a tech-guy? 

I need to learn Flash, pronto.

This looks great.

This is looking very nice, in terms of both graphics and gameplay.

Important note: for as-of-yet unknown reasons, the game occasionally crashes when you select play. Just run it and try it again. Hitting the spacebar re-gen's the terrain. Also, quitting the game and starting another without closing the application is considered cheating until I make it clear all your forts and stuff. XP

EDIT: I found the bug, but I can't be bothered to re-upload it. Don't worry, it only happens 1/32 of the time.

That's looking great man. Hope we get a playable build soon.

Wish and you shall receive.

Except it's more like a devil's wish because it's only a half of "playable build". 

No sound and no real gameplay. Some of the menu options won't do anything when you choose them. It's not a bug, but it's not a feature yet, either.

Download

It's not even a quarter of a megabyte download, so don't hesitate to give it a go.