Free zippo tricks software for linux

poink provides a TCP/IP-based ping tool.

poink is a TCP/IP-based ping implementation that does not require special privileges and is designed for multiuser shell systems. It is intended to be a secure replacement for the standard IPv4 network monitoring tool.

Not much to say... This is a nosuid, so quite secure, version of ping utility
for IPv4. It uses dirty trick - TCP linear SYN/RST challenge instead of
ICMP echo/echo reply. It wont allow any flood-pings (others than connect
flood you could achieve anyway), security compromises etc.

Currently, basic ping parameters are implemented (compatible with
original ping):

ping [ -i delay ] [ -c count ] [ -t timeout ] hostname

-i delay - delay between pings in seconds (default 1, min. 1)
-c count - number of packets to send (default: 0 - until break)
-t timeout - packet timeout in seconds (default: 4, min. 1)

NOTE: longer timeouts might result in slightly inaccurate results because of TCP/IP retransmits.

When finished or stopped with Ctrl+C (SIGINT), poink prints some statistics
about round-trip times, jest like the original ping does. Round-trip times
are displayed in miliseconds (1/1000 of second, ms), but unlike its setuid
counterpart, nosuid ping additionally displays time in microseconds
(1/1000000 of second, usec) if trip time is really low (well, I think that
more recent versions of ping are doing it now, too).

Currently, Linux is the only supported platform, but BSD port should
be really easy to develop.

Gimp::OO is a Perl module with pseudo-OO for Gimp functions.

SYNOPSIS

use Gimp; # Gimp::OO is now part of Gimp.

As you might have noticed, you can sort most gimp functions fall into three groups, depending on the name-prefix: gimp_, plug_in_, extension_ etc..

Whats more, there are functions groups like gimp_image_ or gimp_selection_, operating on a common object, Images and Selection in this case.

If you only had the plain syntax, your scripts would quickly aquire the "vertical gimp syndrome":

gimp_palette_set_foreground(...)
gimp_layer_new(...)
gimp_palette_set_background(...)
gimp_image_add_layer(...)

etc. Of course, your fingers will suffer from severe injuries as well.

A solution to this situation is to use OO-syntax. Gimp plays some (very) dirty tricks and provides a number of classes, like Gimp::Image and Gimp::Palette that allow shorter identifiers to be used (all these appear with the Gimp:: prefix as well as without, i.e. Gimp::Palette is the same class as Palette).

If you call a method, Gimp tries to find a gimp function by prepending a number of prefixes until it finds a valid function:

$image = Gimp->image_new(...); # calls gimp_image_new(...)
$image = Image->new(...); # calls gimp_image_new as well
$image = new Image(...); # the same in green
Palette->set_foreground(...) # calls gimp_palette_set_foreground(..)

Return values from functions are automatically blessed (through The Magic Autobless feature ;) to their corresponding classes, i.e.

$image = new Image(...); # $image is now blessed to Gimp::Image
$image->height; # calls gimp_image_height($image)
$image->flatten; # likewise gimp_flatten($image)
$image->histogram(...); # calls gimp_histogram($image,...), since
# gimp_image_histogram does not exist
The class argument ($image in the above examples) is prepended to the argument list.

Another shortcut: many functions want a (redundant) image argument, like

$image->shear ($layer, ...)

Since all you want is to shear the $layer, not the $image, this is confusing as well. In cases like this, Gimp allows you to write:

$layer->shear (...)

And automatically infers the additional IMAGE-type argument.

As the (currently) last goodie, if the first argument is of type INT32, its name is "run_mode" and there are no other ambiguties, you can omit it, i.e. these three calls are equivalent:

plug_in_gauss_rle (RUN_NONINTERACTIVE, $image, $layer, 8, 1, 1);
plug_in_gauss_rle ($image, $layer, 8, 1, 1);
plug_in_gauss_rle ($layer, 8, 1, 1);

You can call all sorts of sensible and not-so-sensible functions, so this feature can be abused:

patterns_list Image; # will call gimp_patterns_list
quit Plugin; # will quit the Gimp, not an Plugin.

there is no image involved here whatsoever...

Zoids Quest project is a jump-and-run platform game.

Zoids Quest is a platform game in the style of old console games such as Super Mario World and Sonic the Hedgehog.

Players must help Zoid on his Quest by guiding him through many worlds containing tricks, traps, and monsters.

On the way Zoid can collect special magic runes which enhance his abilities and help defend against the many deadly foes.

This is the first public release.

Games::Euchre::Trick is a trick class for Euchre card game.

Only one Trick instance is alive at one time per Euchre game. The Trick keeps track of which cards have been played, and provides useful functions to determine which cards are legal plays, as well as who is the winner of the trick.

The trick class makes the determination of which card beats which card, given the current trump and lead. The trick class knows how to handle an alone hand and it calls the playCard() method for each player in turn in its play() method, usually called from the Games::Euchre->playHand() method.

Games::Irrlicht is a Perl module that use the Irrlicht 3D Engine in Perl.

SYNOPSIS

package MyGame;
use strict;

use base Games::Irrlicht;

use Games::Irrlicht::Constants; get EDT_SOFTWARE etc

# override methods:

The Why

When building a game or screensaver displaying some continously running animation, a couple of basics need to be done to get a smooth animation and to care of copying with varying speeds of the system. Ideally, the animation displayed should be always the same, no matter how fast the system is.

This not only includes different systems (a PS/2 for instance would be slower than a 3 Ghz PC system), but also changes in the speed of the system over time, for instance when a background process uses some CPU time or the complexity of the scene changes.

In many old (especial DOS) games, like the famous Wing Commander series, the animation would be drawn simple as fast as the system could, meaning that if you would try to play such a game on a modern machine it we end before you had the chance to click a button, simple because it wizzes a couple 10,000 frames per second past your screen.

While it is quite simple to restrict the maximum framerate possible, care must be taken to not just "burn" surplus CPU cycles. Instead the application should free the CPU whenever possible and give other applications/thread a chance to run. This is especially important for low-priority applications like screensavers.

Games::Irrlicht makes this possible for you without you needing to worry about how this is done. It will restrict the frame rate to a possible maximum and tries to achive the average framerate as close as possible to this maximum.

Games::Irrlicht also monitors the average framerate and gives you access to this value, so that you can, for instance, adjust the scene complexity based on the current framerate. You can access the current framerate, averaged over the last second (1000 ms) by calling current_fps.

Frame-rate Independend Clock

Now that our application is drawing frames (via the method draw_frame, which you should override in a subclass), we need a method to decouple the animation speed from the framerate.
If we would simple put put an animation step every frame, we would get some sort of Death of the Fast Machine" effect ala Wing Commander. E.g. if the system manages only 10 FPS, the animation would be slower than when we do 60 FPS.

To achive this, SDL::App::FPS features a clock, which runs independed of the current frame rate (and actually, independend of the systems clock, but more on this in the next section).
You can access it via a call to current_time, and it will return the ticks e.g. the number of milliseconds elapsed since the start of the application.

To effectively decouple animation speed from FPS, get at each frame the current time, then move all objects (or animation sequences) according to their speed and display them at the location that matches the time at the start of the frame. See examples/ for an example on how to do this.

Note that it is better to draw all objects according to the time at the start of the frame, and not according to the time when you draw a particular object. Or in other words, treat the time like it is standing still when drawing a complete frame. Thus each frame becomes a snapshot in time, and you dont get nasty sideeffects like one object beeing always "behind" the others just because it gets drawn earlier.

Time Warp

Now that we have a constant animation speed independend from framerate or system speed, lets have some fun.

Since all our animation steps are coupled to the current time, we can play tricks with the current time.

The function time_warp lets you access a time warp factor. The default is 1.0, but you can set it to any value you like. If you set it, for instance to 0.5, the time will pass only half as fast as it used to be. This means instant slow motion! And when you really based all your animation on the current time, as you should, then it will really slow down your entire game to a crawl.

Likewise a time warp of 2 lets the time pass twice as fast. There are virtually no restrictions to the time warp.

For instance, a time warp greater than one lets the player pass boring moments in a game, for instance when you need to wait for certain events in a strategy game, like your factory beeing completed.

Try to press the left (fast forward), right (slow motion) and middle (normal) mousebuttons in the example application and watch the effect.

If you are very bored, press the b key and see that even negative time warps are possible...

Ramping Time Warp

Now, setting the time war to factor of N is nice, but sometimes you want to make dramatic effects, like slowly freezing the time into ultra slow motion or speeding it up again.

For this, ramp_time_warp can be used. You give it a time warp factor you want to reach, and a time (based on real time, not the warped, but you can of course change this). Over the course of the time you specified, the time warp factor will be adapted until it reaches the new value. This means it is possible to slowly speeding up or down.

You can also check whether the time warp is constant or currently ramping by using time_is_ramping. When a ramp is in effect, call ramp_time_warp without arguments to get the current parameters. See below for details.

The example application uses the ramping effect instead instant time warp.

Event handlers

This section describes events as external events that typically happen due to user intervention.
Such events are keypresses, mouse movement, mouse button presses, or just the flipping of the power switch. Of course the last event cannot be handled in a sane way by our framework.

All the events are checked and handled by Games::Irrlicht automatically. The event QUIT (which denotes that the application should shut down) is also carried out automatically. If you want to do some tidying up when this happens, override the method quit_handler.

The event checking and handling is done at the start of each frame. This means no event will happen while you draw the current frame. Well, it will happen, but the action caused by that event will delayed until the next frame starts. This simplifies the frame drawing routine tremendously, since you know that your world will be static until the next frame.

PDL::Primitive Perl module contains primitive operations for pdl.

This module provides some primitive and useful functions defined using PDL::PP and able to use the new indexing tricks.

See PDL::Indexing for how to use indices creatively. For explanation of the signature format, see PDL::PP.

Inner product over one dimension

c = sum_i a_i * b_i
, BadDoc => If a() * b() contains only bad data, c() is set bad. Otherwise c() will have its bad flag cleared, as it will not contain any bad values., ); # pp_def( inner )

pp_def( outer, HandleBad => 1, Pars => a(n); b(m); [o]c(n,m);, Code => loop(n,m) %{ $c() = $a() * $b(); %}, BadCode => loop(n,m) %{ if ( $ISBAD(a()) || $ISBAD(b()) ) { $SETBAD(c()); } else { $c() = $a() * $b(); } %}, Doc => =for ref

outer product over one dimension

Naturally, it is possible to achieve the effects of outer product simply by threading over the "*" operator but this function is provided for convenience.
); # pp_def( outer )

pp_addpm( $c = pdl([[3],[4]]); # A column vector
perldl> $c = pdl(3,4)->(*1); # A column vector, using NiceSlice
perldl> $m = pdl([[1,2],[3,4]]); # A 2x2 matrix
Now that we have a few objects prepared, here is how to matrix-multiply them:
perldl> print $r x $m # row x matrix = row
[
[ 7 10]
]

perldl> print $m x $r # matrix x row = ERROR
PDL: Dim mismatch in matmult of [2x2] x [2x1]: 2 != 1

perldl> print $m x $c # matrix x column = column
[
[ 5]
[11]
]

perldl> print $m x 2 # Trivial case: scalar mult.
[
[2 4]
[6 8]
]

perldl> print $r x $c # row x column = scalar
[
[11]
]

perldl> print $c x $r # column x row = matrix
[
[3 6]
[4 8]
]

Coinflip provides a cryptographically secure server/client program and protocol for choosing random bits.

Coinflip is a client/server based program that can generate random bits for 2 people over the internet. The 2 people dont have to trust each other in order to convince each other that the bit is truly a random bit.

Its called coinflip, of course, because flipping a coin in the real world is the equivalent of generating a random bit on a computer. (Its either heads or tails. Its either a 1 or a 0.)

Coinflip uses a slightly modified version of the "Coin Flipping Using One-Way
Functions" protocol outlined in Bruce Schneiers Applied Cryptography 2nd
edition.

This attack would work everytime Alice acted as the server in a coinflip procedure, providing Bob never realized that Alice was sending him the same y value every time. Or she could us it to trick multiple Bobs.

While it is supposed to be computationally infeasible to compute collisions in one-way hash functions, recent papers suggest that if you have enough money and time, collisions can be precalculated. P. van Oorschot and M. Wiener in their paper, "Parallel collision search with application to hash functions and discreet logarithms", estimate that for $10 million (in 1994 US dollars), a collision could be found for MD5 in 24 days on average. (Thanks for the info, defrost).

The solution is actually quite simple: Have both parties choose part of the random data, and use whatever size random number you like. Since Bob is expecting to see x contain his random data, Alices collision attack is nullified, and since Alice gets to put in her own data, she can make Bobs array attack infeasible.