Games::Dice simulates die rolls. It uses a function-oriented (not
object-oriented) interface. No functions are exported by default.
The number and type of dice to roll is given in a style which should be
familiar to players of popular role-playing games: adb[+-*/b]c. a is optional
and defaults to 1; it gives the number of dice to roll. b indicates the number
of sides to each die. % can be used instead of 100 for b; hence, rolling 2d%
and 2d100 is equivalent. roll simulates a rolls of b-sided dice and adds
together the results. The optional end, consisting of one of +-*/b and a
number c, can modify the sum of the individual dice. +-*/ are similar in that
they take the sum of the rolls and add or subtract c, or multiply or divide
the sum by c. (x can also be used instead of *.) Using b in this slot is a
little different: it's short for "best" and indicates "roll a number of dice,
but add together only the best few". For example, 5d6b3 rolls five six- sided
dice and adds together the three best rolls.
Many people have this experience: You sit before a gambling table. You keep
placing the bet. You know the Goddess will finally smile at you. You just
don't know when. You have only to wait. As the time goes by, the bets in
your hand become fewer and fewer. You feel the time goes slower and slower.
This lengthy waiting process become painfully long, like a train running
straightforwardly into hell. You start feeling your whole life is a failure,
as the jackpot never comes...
But, hey, why so painfully waiting? The Goddess will finally smile at you,
right? So, why not put this painly waiting process to a computer program?
Yes. This is the whole idea, the greatest invention in the century:: An
automatic gambler! There is no secret. It is simple brute force. It
never-endingly runs toward the final jackpot. You can go for other business:
sleep, eat, work. When you finally came back you wins. With it, the hell of
gambling is history!
Remember, that the computer is never affected by emotion, luck, everything.
It never feel anxious or depress. It simply, faithfully, determinedly runs
the probability until the jackpot. As you know, the anxiety and depression
is the enemy of the games, while a simple, faithful and determined mind is
the only path to the jackpot. This makes computer a perfect candidate as a
gambler than an ordinary human.
This is XBattle by Greg Lesher, based on the original by Steve Lehar released
in 1991, and including certain enhancements, modifications, and bug fixes
suggested by a number of contributors from all over the world.
XBattle is a concurrent multi-player game which combines elements of strategy
with arcade-like action to capture a wide range of military scenarios.
The game is based on X Windows, which you must have installed to run xbattle.
Opponents play from separate displays, with commands being executed concurrently
-- the players do not take "turns", but rather they all issue their commands
simultaneously. There can be any number of players, with each player assigned
to a specific team, indicated by marker colors. The game board is a matrix
of cells (square, hexes, etc.) that can be occupied by colored troops,
with the goal of the game being to eliminate the enemy from the board by
attacking cells occupied by enemy troops. A wide variety of command line options
(and previously configured game files) provide an abundance of different
scenarios and gaming environments.
If you have never used xbattle before, read the introduction on the xbattle Web
site. To get the feel of the game, you can run the "tutorial1" and "tutorial2"
scripts supplied with the game. These start a series of small example games that
you can play around with to learn the various options available with the game.
From The README:
Xblackjack is a MOTIF/OLIT based tool constructed to get you ready for the
casino. It was inspired by a book called "Beat the Dealer" by Edward O.
Thorp, Ph.D. of UCLA. A number of important statistics are maintained for
display, and used by the program to implement Thorp's "Complete Point System"
(high-low system).
Beginners can learn a basic strategy which doesn't require counting. The
best strategy employs a simple card counting technique which can be used to
distinguish favorable situations. Avid players can learn to compute Thorp's
high-low index, which takes the number of unseen cards into account.
The index is used by the program to suggest a bet, indicate when you should
buy insurance, and whether you should stand or hit, etc. You can test the
strategy using a slider to control "autoplay mode". Pressing the message
button below the playing area provides hints; the current count, index
and strategy table are revealed.
Cal3D is a skeletal based 3D character animation library written in C++
in a way that is both platform-independent and graphics API-independent.
It was originally designed to be used in a 3D client for Worldforge, but
evolved into a stand-alone product which can be used in many different
kinds of projects.
Cal3D's essentials can be boiled down to 2 parts: the C++ library and
the exporter. The exporter is what you would use to take your characters
(built in a 3D modeling package) and create the Cal3D-format files that
the library knows how to load. The exporters are actually plug-ins for
3D modeling packages. This allows 3D artists to use the modeling tools
that they're already comfortable with.
The C++ library is what you would actually use in your application,
whether it's a game or a VR application. The library provides methods to
load your exported files, build characters, run animations, and access
the data necessary to render them with 3D graphics.
OpenCSG is a library that does image-based CSG rendering using OpenGL.
OpenCSG is written in C++ and supports most modern graphics hardware.
CSG is short for Constructive Solid Geometry and denotes an approach
to model complex 3D-shapes using simpler ones. I.e., two shapes can be
combined by taking the union of them, by intersecting them, or by
subtracting one shape of the other. The most basic shapes, which are
not result of such a CSG operation, are called primitives. Primitives
must be solid, i.e., they must have a clearly defined interior and
exterior. By construction, a CSG shape is also solid then.
Image-based CSG rendering (also z-buffer CSG rendering) is a term that
denotes algorithms for rendering CSG shapes without an explicit
calculation of the geometric boundary of a CSG shape. Such algorithms
use frame-buffer settings of the graphics hardware, e.g., the depth
and stencil buffer, to compose CSG shapes. OpenCSG implements a
variety of those algorithms, namely the Goldfeather algorithm and the
SCS algorithm, both of them in several variants.
Image::Size is a library based on the image-sizing code in the wwwimagesize
script, a tool that analyzes HTML files and adds HEIGHT and WIDTH tags to
IMG directives. Image::Size has generalized that code to return a raw (X, Y)
pair, and included wrappers to pre-format that output into either HTML or a
set of attribute pairs suitable for the CGI.pm library by Lincoln Stein.
Currently, Image::Size can size images in XPM, XBM, GIF, JPEG and PNG
formats.
I did this because my WWW server generates a lot of documents on demand
rather than keeping them in static files. These documents not only use
directional icons and buttons, but other graphics to annotate and highlight
sections of the text. Without size attributes, browsers cannot render the
text of a page until the image data is loaded and the size known for layout.
This library enables scripts to size their images at run-time and include
that as part of the generated HTML. Or for any other utility that uses and
manipulates graphics. The idea of the basic interface + wrappers is to not
limit the programmer to a certain data format.
The OpenGL Character Renderer (GLC) is a state machine that provides
OpenGL programs with character rendering services via an application
programming interface (API).
The character rendering services provided by GLC has some significant
advantages over platform specific interface such as GLX or WGL:
1. The GLC API is platform independent. Since most nontrivial GL
applications render characters, GLC is an important step toward the
goal of truly portable GL applications.
2. The GLC is simpler to use. Only two lines of GLC commands are
required to prepare for rendering characters.
3. GLC provides more ways to exploit the rendering power of OpenGL.
For example, a glyph can be drawn as a bitmap, a set of lines, a
set of triangles, or a textured rectangle.
4. GLC provides better support for glyph transformations. For
example, GLC supports rotated text, which is unavailable in GLX.
5. GLC provides better support for the large coded character set
defined by the standards ISO/IEC 10646:2003 and Unicode 4.0.1
QuesoGLC is a free (as in free speech) implementation of the GLC.
QuesoGLC is based on the FreeType library, provides Unicode support
and is designed to be easily ported to any platform that supports
both FreeType and the OpenGL API.
Lua is a programming language originally designed for extending applications,
but also frequently used as a general-purpose, stand-alone language. Lua
combines simple procedural syntax (similar to Pascal) with powerful data
description constructs based on associative arrays and extensible semantics.
Lua is dynamically typed, interpreted from bytecodes, and has automatic memory
management with garbage collection, making it ideal for configuration,
scripting, and rapid prototyping.
A fundamental concept in the design of Lua is to provide meta-mechanisms for
implementing features, instead of providing a host of features directly in
the language. For example, although Lua is not a pure object-oriented
language, it does provide meta-mechanisms for implementing classes and
inheritance. Lua's meta-mechanisms bring an economy of concepts and keep the
language small, while allowing the semantics to be extended in unconventional
ways. Extensible semantics is a distinguishing feature of Lua.
Lua is implemented as a small library of C functions, written in ANSI C, and
compiles unmodified in all known platforms. The implementation goals are
simplicity, efficiency, portability, and low embedding cost.
Lua is a programming language originally designed for extending applications,
but also frequently used as a general-purpose, stand-alone language. Lua
combines simple procedural syntax (similar to Pascal) with powerful data
description constructs based on associative arrays and extensible semantics.
Lua is dynamically typed, interpreted from bytecodes, and has automatic memory
management with garbage collection, making it ideal for configuration,
scripting, and rapid prototyping.
A fundamental concept in the design of Lua is to provide meta-mechanisms for
implementing features, instead of providing a host of features directly in
the language. For example, although Lua is not a pure object-oriented
language, it does provide meta-mechanisms for implementing classes and
inheritance. Lua's meta-mechanisms bring an economy of concepts and keep the
language small, while allowing the semantics to be extended in unconventional
ways. Extensible semantics is a distinguishing feature of Lua.
Lua is implemented as a small library of C functions, written in ANSI C, and
compiles unmodified in all known platforms. The implementation goals are
simplicity, efficiency, portability, and low embedding cost.