Tremulous is a free, open source game that blends a team based FPS with
elements of an RTS. Players can choose from 2 unique races: aliens and
humans. Players on both teams are able to build working structures in-game
like an RTS. These structures provide many functions, the most important
being spawning. The designated builders must ensure there are spawn
structures or other players will not be able to rejoin the game after death.
Other structures provide automated base defense (to some degree), healing
functions, and much more.
Player advancement is different depending on which team you are on. As a
human, players are rewarded with credits for each alien kill. These credits
may be used to purchase new weapons and upgrades from the "Armoury". The
alien team advances quite differently. Upon killing a human foe, the alien
is able to evolve into a new class. The more kills gained the more powerful
the classes available.
The overall objective behind Tremulous is to eliminate the opposing team.
This is achieved by not only killing the opposing players but also removing
their ability to respawn by destroying their spawn structures.
Book of Psalms from the Douai Bible (1610) in fortune(6) file format
In general, taking random out-of-context verses from a Bible is a
VERY bad idea. This said, this is an experiment to generate a not
too bad fortune-cookie database under the following principles:
- Only the text from the psalms, which are usually meant for praying,
were taken.
- The texts always include at least some context: you are always
notified where the text came from and there is always sufficient
text so that the phrases make sense.
- The text was taken from the classic Douai Bible, a direct translation
from the latin Vulgata. The old language will not give you false
impressions that you are actually understanding it fully.
- No effort was done to remove the original comments. Non-Christians
may rightfully feel the translation is biased.
This is meant to be a general aid for Christian meditation: it is not
generally to be taken as my message-of-the-day from God.
To use, you need UNIX fortune(6) utility and you should follow the
instructions from the corresponding man page.
Bytes::Random::Secure provides two interfaces for obtaining crypto-quality
random bytes. The simple interface is built around plain functions. For greater
control over the Random Number Generator's seeding, there is an Object Oriented
interface that provides much more flexibility.
The "functions" interface provides functions that can be used any time you need
a string of a specific number of random bytes. The random bytes are available as
simple strings, or as hex-digits, Quoted Printable, or MIME Base64. There are
equivalent methods available from the OO interface, plus a few others.
This module can be a drop-in replacement for Bytes::Random, with the primary
enhancement of using a cryptographic-quality random number generator to create
the random data. The random_bytes function emulates the user interface of
Bytes::Random's function by the same name. But with Bytes::Random::Secure the
random number generator comes from Math::Random::ISAAC, and is suitable for
cryptographic purposes. The harder problem to solve is how to seed the
generator. This module uses Crypt::Random::Seed to generate the initial seeds
for Math::Random::ISAAC.
Unix provides the standard du utility, which scans your disk and tells you which
directories contain the largest amounts of data. That can help you narrow your
search to the things most worth deleting.
However, that only tells you what's big. What you really want to know is what's
too big. By itself, du won't let you distinguish between data that's big because
you're doing something that needs it to be big, and data that's big because you
unpacked it once and forgot about it.
Most Unix file systems, in their default mode, helpfully record when a file was
last accessed. Not just when it was written or modified, but when it was even
read. So if you generated a large amount of data years ago, forgot to clean it
up, and have never used it since, then it ought in principle to be possible to
use those last-access time stamps to tell the difference between that and a
large amount of data you're still using regularly.
agedu is a program which does this. It does basically the same sort of disk scan
as du, but it also records the last-access times of everything it scans. Then it
builds an index that lets it efficiently generate reports giving a summary of
the results for each subdirectory, and then it produces those reports on demand.
This is tidy-devel, built with a shared lib.
When editing HTML it's easy to make mistakes. Wouldn't it be nice if
there was a simple way to fix these mistakes automatically and tidy up
sloppy editing into nicely layed out markup? Well now there is thanks
to Hewlett Packard's Dave Raggett. HTML TIDY is a free utility for
doing just that. It also works great on the attrociously hard to read
markup generated by specialized HTML editors and conversion tools, and
can help you identify where you need to pay further attention on
making your pages more accessible to people with disabilities.
Tidy is able to fix up a wide range of problems and to bring to your
attention things that you need to work on yourself. Each item found is
listed with the line number and column so that you can see where the
problem lies in your markup. Tidy won't generate a cleaned up version
when there are problems that it can't be sure of how to handle. These
are logged as "errors" rather than "warnings".
Xcd is a simple GUI to control a CD player. It requires Tcl/Tk to be
installed on your system.
Xcd has the usual buttons to control a CD player: "play",
"pause/resume", "stop", "eject", "next track", "previous track",
"rewind", "forward" and a volume slider. Xcd displays continuously the
current track number and the elapsed time of the track. Pressing the
left mouse button on the "track" label causes Xcd to display the total
number of the tracks and the total duration of the disk. Pressing the
left mouse button on the "time" label causes xcd to display the
duration of the current track. Pressing the middle mouse button on
the "track" button allows to choose a track number to play.
LevelDB is a fast key-value storage library written at Google that provides an
ordered mapping from string keys to string values.
Features:
- Keys and values are arbitrary byte arrays.
- Data is stored sorted by key.
- Callers can provide a custom comparison function to override the sort order.
- The basic operations are Put(key,value), Get(key), Delete(key).
- Multiple changes can be made in one atomic batch.
- Users can create a transient snapshot to get a consistent view of data.
- Forward and backward iteration is supported over the data.
- Data is automatically compressed using the Snappy compression library.
- External activity (file system operations etc.) is relayed through a virtual
interface so users can customize the operating system interactions.
- Detailed documentation about how to use the library is included with the
source code.
CFFI, the Common Foreign Function Interface, purports to be a
portable foreign function interface for Common Lisp. The CFFI library
is composed of a Lisp-implementation-specific backend in the CFFI-SYS
package, and a portable frontend in the CFFI package.
The CFFI-SYS backend package defines a low-level interface to the
native FFI support in the Lisp implementation. It offers operators
for allocating and dereferencing foreign memory, calling foreign
functions, and loading shared libraries. The CFFI frontend provides
a declarative interface for defining foreign functions, structures,
typedefs, enumerated types, etc. It is implemented in portable ANSI
CL making use of the low-level operators exported by CFFI-SYS.
This package is compiled with SBCL.
Codeville is a distributed Version Control System. It began with a novel
idea for a merge algorithm, and has grown from there. It is designed to
be easy to use, and scale from small personal projects, to very large
distributed ones. If you'd like to know why there's need for new merge
algorithms, consider what the lead monotone developer had to say:
http://article.gmane.org/gmane.comp.version-control.monotone.devel/3264
Codeville works by creating an identifier for each change that is done,
and remembering the list of all changes which have been applied to each
file, and the last change which modified each line in each file. When
there's a conflict, it checks to see if one of the two sides has already
been applied to the other one, and if so, makes the other side win
automatically. When there's a non automatically mergeable version conflict,
Codeville behaves in almost exactly the same way as CVS.
Developing and debugging UIs can be a pain. When something
goes wrong, it's not always obvious why. You can waste hours
writing logging statements only to find out that a widget is
in the wrong container, or an attribute wasn't set correctly.
Developing isn't much better either. Ever spend time writing
temporary code just to test a new feature, code you know you're
going to throw away in an hour, and yet you end up spending the
next 20 minutes debugging your temporary code? Sucks, doesn't
it?
What your program really needs is a good Parasite infestation.
Parasite is a debugging and development tool that runs inside
your GTK+ application's process. It can inspect your application,
giving you detailed information on your UI, such as the hierarchy,
X window IDs, widget properties, and more. You can modify properties
on the fly in order to experiment with the look of your UI.