mercurial-server gives your developers remote read/write access to centralized
Mercurial repositories using SSH public key authentication; it provides
convenient and fine-grained key management and access control.
All of the repositories controlled by mercurial-server are owned by a single
user (the "hg" user in what follows), but many remote users can act on them,
and different users can have different permissions. We don't use file
permissions to achieve that - instead, developers log in as the "hg" user
when they connect to the repository host using SSH, using SSH URLs of the
form "ssh://hg@repository-host/repository-name". A restricted shell prevents
them from using this access for unauthorized purposes. Developers
are authenticated only using SSH keys; no other form of authentication is
supported.
To give a user access to the repository, place their key in an
appropriately-named subdirectory of "/usr/lcoal/etc/mercurialserver/keys"
and run "refresh-auth". You can then control what access they have to what
repositories by editing the control file
"/usr/local/etc/mercurialserver/access.conf", which can match the names of
these keys against a glob pattern.
For convenient remote control of access, you can instead (if you have the
privileges) make changes to a special repository called "hgadmin", which
contains its own "access.conf" file and "keys" directory. Changes pushed to
this repository take effect immediately. The two "access.conf" files are
concatenated, and the keys directories merged.
Celluloid::IO provides an event-driven IO system for building fast, scalable
network applications that integrates directly with the Celluloid actor library,
making it easy to combine both threaded and evented concepts. Celluloid::IO is
ideal for servers which handle large numbers of mostly-idle connections, such as
Websocket servers or chat/messaging systems.
Celluloid::IO provides a different class of actor: one that's slightly slower
and heavier than standard Celluloid actors, but one which contains a
high-performance reactor just like EventMachine or Cool.io. This means
Celluloid::IO actors have the power of both Celluloid actors and evented I/O
loops. Unlike certain other evented I/O systems which limit you to a single
event loop per process, Celluloid::IO lets you make as many actors as you want,
system resources permitting.
Rather than callbacks, Celluloid::IO exposes a synchronous API built on duck
types of Ruby's own IO classes, such as TCPServer and TCPSocket. These classes
work identically to their core Ruby counterparts, but in the scope of
Celluloid::IO actors provide "evented" performance. Since they're drop-in
replacements for the standard classes, there's no need to rewrite every library
just to take advantage of Celluloid::IO's event loop and you can freely switch
between evented and blocking IO even over the lifetime of a single connection.
gFTP is a free multithreaded FTP and SFTP client for Unix-like systems.
It has the following features:
Distributed under the terms of the GNU Public License
Written in C, has a text interface and a GTK+ 2.x interface
Supports the FTP, FTPS (control connection only), HTTP, HTTPS, SSH, and FSP
Multithreaded to allow for simultaneous downloads
File transfer queues to allow for downloading multiple files
Bookmarks menu to allow you to quickly connect to remote sites
Supports downloading entire directories and subdirectories
Extensive connection manager with FTP and HTTP proxy server support
Supports resuming interrupted file transfers
Supports caching of remote directory listings
Supports connecting to a FTP server via command line parameters
Supports associating icons with particular file extensions in the list boxes
Sorting capabilities in the file list boxes
Can restrict files in the list boxes to a particular file specification
Supports viewing and editing of local and remote files
Allows for passive and non-passive file transfers
Supports FXP file transfers (file transfer between 2 remote servers via FTP)
Eliminates buffer overruns from malicious FTP sites
This project aims to reimplement the game engine of Theme Hospital, and be
able to load the original game data files. This means that you will need
a purchased copy of Theme Hospital, or a copy of the demo, in order to use
CorsixTH. After most of the original engine has been reimplemented, the
the project will serve as a base from which extensions and improvements to
the original game can be made.
At the moment, game assets (graphics, sounds, levels, translations, etc.)
are loaded from the original game files. Therefore, you will require a
pre-existing Theme Hospital install in order to use CorsixTH. If you've
got a copy of the original game disk lying around, then great -- copy the
HOSP folder (which should contain directories called Data, QData, Levels,
etc.) from the root of the CD to somewhere on your hard drive, and use
this for the theme_hospital_install setting later. If you are unable to
acquire the full game data files, then the demo can be downloaded easily
and used instead (though the demo only has one level, and lacks most of
the management screens).
Liquid War is a unique multiplayer wargame. Its rules are truely
original and have been invented by Thomas Colcombet. You control
an army of liquid and have to try and eat your opponents. A single
player mode is available, but the game is definitely designed to
be multiplayer, and has network support.
When playing Liquid War, one has to eat one's opponent. There can
be from 2 to 6 players. There are no weapons, the only thing you
have to do is to move a cursor in a 2-D battlefield. This cursor
is followed by your army, which is composed by a great many little
fighters. Fighters are represented by small colored squares. All
the fighters who have the same color belong to the same team. One
very often controls several thousands fighters at the same time.
And when fighters from different teams meet, they eat each other,
it is as simple as that.
Note: If the game crashes this might resolve it:
Inside liquidwar, go to options->rules->advanced and change
Algorithm from "Assembly" to "Standard C"
See also the "ASM" option in the port build options.
OpenLieroX is based and compatible to the famous LieroX. LieroX is
a 2D shooter game. It is an unofficial sequel to Liero, and is the
most popular of all the Liero clones. It features online play, fully
customizable weapons, levels and characters. Liero Xtreme was created
in C++ by Jason 'JasonB' Boettcher, an Australian programmer.
The game is based on a deathmatch setting, where multiple players
face off in a closed level. Each player is equipped with five weapons
selected out of all the weapons allowed, and with a ninja rope that
allows the player to move in any direction. Players begin with a
set amount of lives, and whilst the game records the number of
kills, the last man standing is usually considered the winner.
LieroX also allows team deathmatches, which has made it common for
players to form clans.
Because of the huge community, there are dozens of levels and mods
available. You also have no problem to find somebody on Internet
to play with. Or if you want to play offline, you also can play
with bots.
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.
World of Padman (WoP) is an open source first-person shooter computer game
available in both English and German. Originally it was a modification for
the Quake III Arena titled PadMod, created in the year 2004.
After the source code for the Quake III Arena was released, the game became
standalone. The idea is based on the Padman comic strip for the magazine
PlayStation Games, created by the professional cartoon artist Andreas "ENTE"
Endres, who is also the man who made many of the maps included with the game
in 1998.
The current version runs on an enhanced version of the ioquake3 engine, which
is based on the Quake III Arena engine. Most of the maps in the game are
lilliput style, and have a commercial-quality level of graphic complexity.
Because it was originally a mod for Quake III Arena, most of the gameplay is
similar. However, there is no Capture the Flag mode in World of Padman.
World of Padman fully supports bots with a variety of skill levels in both
online and offline play for all of the game types included. A single-player
mode has not yet been implemented. Players can also record audio and video
as they play. The game fully supports modifications, and custom maps can be
created.
A no-nonsense, simple to use, small viewer for cbr and cbz (comic book archive)
files. As it is written in C, the executable is small and fast. It views jpg
(or jpeg), gif and png images, and you can zoom in and out.
It's main features are:
* Simple usage: A navigation bar stays on top of the pages.
* It works on any RAR-compressed image archive - normally the extension
would be .cbr or .cbz, but other extensions work too.
* Advance/backup pages, and go to the begin and end.
* Zoom in and zoom out (10% steps) and return to 1:1.
* It should manage jpeg (jpg), png and gif images.
* A configuration window permits defining a few slightly more advanced
tricks:
* When advancing go to the top of the next page (or bottom or stay where you
are.)
* Same possibilities when paging backwards.
* Remember the last directory visited on startup, or always start in a
defineable directory.
* Determine the initial size of the pager.
* Define where the navigation bar should be and its orientation.
Graphic Counter Language is a powerful programming language for the creation of
graphic and textual counters and timers. These can be used on the web, as well
as in graphic application programs (such as XWindow applications) which can
call the GCL interpeter internally and have it create a counter or a timer.
Gracula is the compiler/interpreter for Graphic Counter Language, developed
under FreeBSD, though usable on any Unix system.
For details about the language, visit GCL home page (www.whizkidtech.net/gcl/)
as well as Count Gracula's Gallery (www.whizkidtech.redprince.net/gcl/gallery)
which contains a number of sample GCL scripts and showcases various counter
designs.
GCL requires no configuration files. All you provide is graphic images and
simple scripts. Optionally, you may link the images directly into the gracula
executable. GCL can also receive input from external programs. A sample program
is included (sec2000). It allows the creation of GCL counters to display the
number of seconds (or minutes, hours, days) left till the Year 2000.
Gracula is written in C and highly optimized for speed which makes it work
reliably even on the busiest web sites.