Free catch the knuddelmonster software for linux

Catch the Knuddelmonster project is a puzzle/action game.

The goal of the game is leading the Knuddelmonster along a small path to "Mimi". The game is based on the "ClanLib" library.

Exception::System is the exception class for system or library calls.

SYNOPSIS

# Loaded automatically if used as Exception::Bases argument
use Exception::Base
Exception::System,
Exception::File => { isa => Exception::System };

try Exception::Base eval {
my $file = "/notfound";
open FILE, $file
or throw Exception::File message=>"Can not open file: $file",
file=>$file;
};
if (catch Exception::System my $e) {
if ($e->isa(Exception::File)) { warn "File error:".$e->{errstr}; }
if ($e->with(errname=>ENOENT)) { warn "Catched not found error"; }
}

This class extends standard Exception::Base with handling system or library errors. The additional fields of the exception object are filled on throw and contain the error message and error codes.

FIELDS

Class fields are implemented as values of blessed hash.

errstr (ro)

Contains the system error string fetched at exception throw. It is the part of the string representing the exception object. It is the same as $! variable in string context.

eval { throw Exception::System message=>"Message"; };
catch Exception::System my $e
and print $e->{errstr};

errstros (ro)

Contains the extended system error string fetched at exception throw. It is the same as $^E variable.

eval { throw Exception::System message=>"Message"; };
catch Exception::System my $e and $e->{errstros} ne $e->{errstr}
and print $e->{errstros};

errno (ro)

Contains the system error number fetched at exception throw. It is the same as $! variable in numeric context.

eval { throw Exception::System message=>"Message"; };

errname (ro)

Contains the system error constant from the system error.h include file.

eval { throw Exception::System message=>"Message"; };
catch Exception::System my $e and $e->{errname} eq ENOENT
and $e->throw;

METHODS

stringify([$verbosity[, $message]])
Returns the string representation of exception object. The format of output is "message: error string".

eval { open F, "/notexisting"; throw Exception::System; };
print $@->stringify(1);
print "$@";

Genuts Breaker project is a remake of the popular classic Break-Out game.
How to play "Genuts Breaker":
- Dont loose your ball, catch it with your racket.
- Use left and right keys, or the mouse to control the racket.
- Sometime a new ball will appear.
- 6 levels are available.
The game can be paused by pressing the space bar or the mouse button.
Enhancements:
- Changes were done to respect Genuts Framework 0.7.1b specifications.

Exception::Base is a Perl module with lightweight exceptions.
SYNOPSIS
# Use module and create needed exceptions
use Exception::Base (
Exception::IO,
Exception::FileNotFound => { message => File not found,
isa => Exception::IO },
);
# try / catch
try Exception eval {
do_something() or throw Exception::FileNotFound
message=>Something wrong,
tag=>something;
};
# Catch the Exception::Base, other exceptions throw immediately
if (catch Exception::Base my $e) {
# $e is an exception object for sure, no need to check if is blessed
if ($e->isa(Exception::IO)) { warn "IO problem"; }
elsif ($e->isa(Exception::Die)) { warn "eval died"; }
elsif ($e->isa(Exception::Warn)) { warn "some warn was caught"; }
elsif ($e->with(tag=>something)) { warn "something happened"; }
elsif ($e->with(qr/^Error/)) { warn "some error based on regex"; }
else { $e->throw; } # rethrow the exception
}
# the exception can be thrown later
$e = new Exception::Base;
$e->throw;
# try with array context
@v = try Exception::Base [eval { do_something_returning_array(); }];
# use syntactic sugar
use Exception::Base qw , Exception::IO;
try eval {
throw Exception::IO;
}; # dont forget about semicolon
catch my $e, [Exception::IO]; # Exception::Base is by default
This class implements a fully OO exception mechanism similar to Exception::Class or Class::Throwable. It does not depend on other modules like Exception::Class and it is more powerful than Class::Throwable. Also it does not use closures as Error and does not polute namespace as Exception::Class::TryCatch. It is also much faster than Exception::Class.
Main features:
- fast implementation of an exception object
- fully OO without closures and source code filtering
- does not mess with $SIG{__DIE__} and $SIG{__WARN__}
- no external modules dependencies, requires core Perl modules only
- implements error stack, the try/catch blocks can be nested
- shows full backtrace stack on die by default
- the default behaviour of exception class can be changed globally or just for the thrown exception
- the exception can be created with defined custom properties
- matching the exception by class, message or custom properties
- matching with string, regex or closure function
- creating automatically the derived exception classes ("use" interface)
- easly expendable, see Exception::System class for example

File Selection Language (FSL) is a descriptive language for file selection. File Selection Language is used to selectively pick files from a directory structure.
FSL is useful for selective backups, for instance. FSL uses glob patterns as the basic building block.
For fine-tuning the selection, inclusion/exclusion rule combinations and conditional expressions are available. File size and modification date can be used in expressions.
Main features:
- FSL can be used with a command line tool (fsltool) or, for Python programmers, with a programmable interface. For the Python interface, see the documentation of Interpreter.py.
- Several FSL rule files can be combined in a cascading manner similar to CSS. The effect is the same as if the rule files were pasted into a single file.
- Support for both Windows-like and Unix-like paths.
- Strict parse-time type checking to catch as many errors as possible before run-time. For example, you cant say EACH f IF size(5) > 1000 because function size expects filename argument.

Class::Multimethods::Pure is a Perl module that contains a method-ordered multimethod dispatch.

SYNOPSIS

use Class::Multimethods::Pure;

package A;
sub magic { rand() > 0.5 }
package B;
use base A;
package C;
use base A;

BEGIN {
multi foo => (A, A) => sub {
"Generic catch-all";
};

multi foo => (A, B) => sub {
"More specific";
};

multi foo => (subtype(A, sub { $_[0]->magic }), A) => sub {
"This gets called half the time instead of catch-all";
};

multi foo => (any(B, C), A) => sub {
"Accepts B or C as the first argument, but not A"
};
}

Guarded Memory Move project gets handy when you have to study buffer overflows and you need to catch them together with a "good" stack image. When a stack overflow has been exploited, the back trace is already gone together with good information about parameters and local variables, that are of vital importance when trying to understand how the attacker is trying to work out the exploit. The GMM library uses dynamic function call interception to catch the most common functions that are used by attackers to exploit stack buffers.
The GMM library uses the LD_PRELOAD capability and offers two services to the user. First of all, it avoids buffer overflow to allow the attacker to execute shell-code on your machine. Second, in case where an exploit is detected, the stack content is saved and a segmentation fault is triggered. The resulting core dump will then have all the necessary information to debug the exploit and fix the software. Internally, the library insert itself between the application and the glibc library and intercept functions that might lead to buffer overflow exploits. Before calling the glibc core function, the GMM layer saves part of the stack frame above the caller to a temporary location in its frame.
It also stores the previous three return addresses in its local storage before calling the glibc core function. When the core function returns, the GMM code samples again the previously recorded return addresses and, if they differ, it restores the previously saved stack frame and issue a segmentation fault. This with a clean stack frame, so that it can be inspected with a debugger. While other solutions exist to detect buffer overflow exploits, like for example StackGuard and StackShield, those differs from GMM in many ways. They live as gcc patches and do require you to rebuild your application to use their functionalities. The good of this approach is that every single function is protected against buffer overflows.
The bad of this solution is that every single function is protected against buffer overflows. That is, performance regression on the whole application, even if this is not really a huge problem when hunting for buffer overflows. Another solution similar to GMM is LibSafe, but it does not save and restore the stack frame by making it unusable for debugging. But lets see how GMM differs from the above listed solutions. First of all, GMM works everywhere there are stack frames and the gcc and glibc duo. That means that it is not limited to i386 only. And now the real reason for the GMM existence.
Enhancements:
- GCCs __builtin_return_address and __builtin_frame_address seems to return garbage instead of NULL at the last frame. This release fixes the problem.

Hell World is a thrilling FPS adventure game which features excellent graphics, a dark atmosphere and an excellent scenario. Hell World game is designed to be a port of the Windows-only version of Hell World.
It is written using the openGL and SDL library and is developing for the last months by ironhell3.
The game starts from main.c There we call first two functions, sdl_init() and game_init() to initialise the sdl and game part of the game.After the succesfull initialisation of Hell World we loop in a while() function.Each frame we check the keyboard and mouse for events through keyhandler() and then render the game frames through loop().When we catch a done=true signal we quit the game.
Important:
1)We are in need of developers,musicians,artists etc to help develop this game
2)This game is released under the GPL license.Please READ the COPYING file for more info
Enhancements:
- Fixed movement
- Added fog
- Added crates
- Redesign of level 1 including texture changes