Bay 12 Games Forum

I had a magical moment where it was raining in Dwarf Fortress while simultaneously there was the sound of rain from a video I had on in the background, and I realized then that having something that played atmospheric sounds to accompany the game would add so much. Is there anything that does this currently? I saw SoundSense, but it seemed to be much more focused on one-off sound effects than ambiance.

I'm working on a little modding tool and I'm finding that the most difficult part is understanding how tokens in the raws relate to each other. How do I know that [CASTE], for example, is a property of [CREATURE], and [MALE] and [FEMALE] are properties of [CASTE]? The indentation in the raws isn't consistent enough to programmatically deduce it from the files themselves in any practical and reliable way. Is there any resource accurate and kept up-to-date which fully documents which tokens are properties of which?

The Banshee Engine is an engine I've been developing which is targeted at making ANSI-based games very easy to make. It features Lua scripting and a ton of conveniences as well as huge measures taken for optimization. Games designed for the Banshee Engine are pretty damn portable - they'll run even on decade-old hardware (I have verified this myself) and the engine will be compiled for Windows, Mac, and Linux. Along with the engine I'm developing a game called Titan in which you play as a detective tasked with uncovering the truth behind an apparently alien attack upon a research installation on that Saturn's moon.


Devlog

You wake up to the sight of a beautiful alien landscape after a group of terrorists attack your fleet. You've crash-landed, but were saved by the technology of your craft, sacrificing itself for your safe landing.

With no weapon you set out into the wilderness in search of civilization, hoping to rejoin your fleet and return to the war being fought galaxies away.

Thus begins Deshori, an exploration-based FPG.

Things are not entirely as they appear as you cross the seemingly calm desert.

Strange creatures, abandoned cities, violent nomads, giant monuments, and many other surprises await you along the way.



Present devlog

Some incredibly attention-grabbing video footage

An insightful image gallery

twirly gif:



Deshori is a game project being worked on by Derek Sneed and yours truly, with the intent of making an environment with some genuinely interesting AI, among other neat things. The idea of doing this without some kind of funding is pretty fantastic, so if you have a few dollars to spare you really ought to check out our kickstarter. For an $8 commitment you get the game, and the game would cost more than that when it's released, so you'd be getting a free wad of bucks out of shelling over money ordering our lovechild early.

Regardless of whether you love us enough to give us your money that you managed to scam your boss or allowance-paying parents out of, I believe this is going to be a wonderfully interesting experience of a game, and you should keep a look out for it. However, if there's any time when your contribution could directly mean the difference between a game existing and not, this is probably that time.

Finiteer allows you to safely preserve your init.txt settings when a new version comes out without needing to rummage through the new file and change everything up.

Simply paste the contents of your current init.txt file into finiteer.txt, place the file and the program either inside your dwarf fortress folder or in the same directory as your df_[version] folder. Run Finiteer.exe and viola, your settings have safely been transfered.

Download

Hello, world!
>[64]j[8]
$8
}[32].i[9]}[9]?[8];_
$32
Hello,[32]world!
$64
[45]// 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:
>[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
_// 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. //
Command reference:
Push, pop for the A, B, C registers
> <
} {
) (
arguments: [memory address]

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
^ ` '
arguments: [position in string]

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, swap two bytes in memory from one place to another
# S
arguments: [origin memory address],[second memory address]

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
arguments: [jump to address]

Jump if A > B
?
arguments: [jump to address]

Jump if A < B
!
arguments: [jump to address]

Jump if A = B
=
arguments: [jump to address]

Jump if A != B
N
arguments: [jump to address]

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
\

Shift a value in memory left, right by one bit
L R
arguments: [memory address]

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
Mean: m
Logical OR: O
Logical AND: A
Logical XOR: X

Creates a new external data file if one doesn't already exist. It opens it into memory if it does.
F
arguments: [file #]

Write a value from a program memory address into a file
w
arguments: [write from memory address],[write to file address]

Read a byte from a file and store it in program memory
p
arguments: [write to memory address],[read from file address]

Read the entire contents from a file and store it in program memory starting at a given address
P
arguments: [begin writing to memory address]

Kill program
_

Comment
// (...) //

Set string memory contents before runtime - first instance sets first string, second instance sets second string.
"(...)
Nonfunctional BF interpreter
// Program code //

">>>++.<<<.#
// Please use a "#" to indicate EOF. //

// BrainF*ck interptreter //


j[20]


$4
 // Constants //
[62] // 04: > //
[60] // 05: < //
[91] // 06: [ //
[93] // 07: ] //
[43] // 08: + //
[45] // 09: - //
[46] // 10: . //
[48] // 11: , //
[35] // 12: # (EOF) //
 // Variables //
[0] // 13:    Current in-code position //
[96] // 14:    Current tape position //
[0][0][0][0] // 15-18: Last 4 [ positions //
[0] // 19:    Current [] nest //

// memory address 20 //


$20

^[13] // Push the command into A //

$22
}[04] // Push ">" into B //
N[30]
i[14]
j[144]

$30
}[05] // Push "<" into B //
N[38]
d[14]
j[144]

$38
}[08] // Push "+" into B //
N[49]
#[14][46]
i[ 0 ]
j[144]

$49
}[09] // Push "-" into B //
N[60]
#[14][57]
d[ 0 ]
j[144]

$60
}[10] // Push "." into B //
N[74]
#[14][68]
)[ 0 ]
~,;s~
j[144]

$76
}[11] // Push "," into B //
N[88]
~\~
#[14][87]
'[ 0 ]

$88
}[06] // Push "[" into B //
N[108]
i[19]
S[18][17]
S[17][16]
S[16][15]
#[13][15]
j[144]

$108
}[07] // Push "]" into B //
N[139]
}[0]
#[14][118]
>[ 0 ]
N[134]
d[19]
#[16][15]
#[17][16]
#[18][17]
j[144]
#[15][13]
j[144]

$139
}[12] // Push "#" (EOF) into B //
N[144]
_




$144
i[13] // increment position in code //

// keep tape address within bounds //
>[13]
}[170]
N[157]
#[172][13]
j[20]
$157
}[171]
N[20]
#[173][13]
j[20]
$166

$170
[0][190][191][255]

// Tape spans from $191 - $255 //


Download

reference.txt for a command reference, readme.txt for instructions on how to use it.

I must have feedback!

Ahar, release!

At the moment, it can't do anything to the raws, I haven't worked on that yet since this rewrite. The code will be easy to transfer from the previous work, though.

Please read the comments in the code file to get an idea of what's going on.

Download

Conditional statements and loops are probably next. Shouldn't take long, I've already got the groundwork implemented in the parsing loop.








I figure now's as good a time as any to announce this. RawScript is a program that functions similarly to UristMod, but with several improvements.

What it's got so far:
+ Intelligent parsing of the raw files and efficient version-independant recognition of tokens and object types
+ Easy, comprehendable syntax for choosing what objects in the raws you want your changes to affect
+ Removing tags from the objects, appending them to their ends, and changing the arguments of existing ones
+ Conditional modification to aid inter-mod compatibility

What I'll be adding before I release it:
- Apply changes only to certain castes
- More flexible object selection capabilities
- Create and delete entire objects from the raws
- Write thorough documentation
- Record changes installed to a separate file to allow streamlined uninstallation of modifications.

Here's an example of a functional* program in RawScript

Include OBJECT:CREATURE
Select TOKEN:PET_EXOTIC
Remove PET_EXOTIC
Append PET
Exclude *
Include OBJECT:CREATURE
Select TOKEN:MOUNT_EXOTIC
Remove MOUNT_EXOTIC
Append MOUNT

*minus a couple bugs, and it probably wouldn't work too well considering I haven't finished caste support just yet 

Square (16x16) version:


Fixed the spade character, the t, and the i (12x16):




Old:




(Could someone do me a favor and provide some screenshots? My computer's been screwing up with print screen.)

This is what I can provide, though: