Free streets software for linux

Geo::StreetAddress::US is a Perl extension for parsing US street addresses.

SYNOPSIS

use Geo::StreetAddress::US;

my $hashref = Geo::StreetAddress::US->parse_location(
"1005 Gravenstein Hwy N, Sebastopol CA 95472" );

my $hashref = Geo::StreetAddress::US->parse_location(
"Hollywood & Vine, Los Angeles, CA" );

my $hashref = Geo::StreetAddress::US->parse_address(
"1600 Pennsylvania Ave, Washington, DC" );

my $hashref = Geo::StreetAddress::US->parse_intersection(
"Mission Street at Valencia Street, San Francisco, CA" );

my $normal = Geo::StreetAddress::US->normalize_address( %spec );
# the parse_* methods call this automatically...

Geo::StreetAddress::US is a regex-based street address and street intersection parser for the United States. Its basic goal is to be as forgiving as possible when parsing user-provided address strings.

Geo::StreetAddress::US knows about directional prefixes and suffixes, fractional building numbers, building units, grid-based addresses (such as those used in parts of Utah), 5 and 9 digit ZIP codes, and all of the official USPS abbreviations for street types and state names.

LMarbles is an Atomix clone with a slight change in concept. Instead of assembling molecules you create figures out of marbles. Nevertheless, the basic game play is the same: If a marble starts to move it will not stop until it hits a wall or another marble.

To make it more interesting there are obstacles like one-way streets, crumbling walls and portals.

As Marbles is meant as a puzzle game you play against a move limit and not a time limit. This way you have as much time as you need to think.

XML::Rules is a Perl module that can parse XML & process tags by rules starting from leaves.

SYNOPSIS

use XML::Rules;

$xml = < < *END*
< doc >
< person >
< fname >...< /fname >
< lname >...< /lname >
< email >...< /email >
< address >
< street >...< /street >
< city >...< /city >
< country >...< /country >
< bogus >...< /bogus >
< /address >
< phones >
< phone type="home" >123-456-7890< /phone >
< phone type="office" >663-486-7890< /phone >
< phone type="fax" >663-486-7000< /phone >
< /phones >
< /person >
< person >
< fname >...< /fname >
< lname >...< /lname >
< email >...< /email >
< address >
< street >...< /street >
< city >...< /city >
< country >...< /country >
< bogus >...< /bogus >
< /address >
< phones >
< phone type="office" >663-486-7891< /phone >
< /phones >
< /person >
< /doc >
*END*

@rules = (
_default = > sub {$_[0] = > $_[1]- >{_content}},
# by default Im only interested in the content of the tag, not the attributes
bogus = > undef,
# lets ignore this tag and all inner ones as well
address = > sub {address = > "$_[1]- >{street}, $_[1]- >{city} ($_[1]- >{country})"},
# merge the address into a single string
phone = > sub {$_[1]- >{type} = > $_[1]- >{content}},
# lets use the "type" attribute as the key and the content as the value
phones = > sub {delete $_[1]- >{_content}; %{$_[1]}},
# remove the text content and pass along the type = > content from the child nodes
person = > sub { # lets print the values, all the data is readily available in the attributes
print "$_[1]- >{lname}, $_[1]- >{fname} < $_[1]- >{email} >n";
print "Home phone: $_[1]- >{home}n" if $_[1]- >{home};
print "Office phone: $_[1]- >{office}n" if $_[1]- >{office};
print "Fax: $_[1]- >{fax}n" if $_[1]- >{fax};
print "$_[1]- >{address}nn";
return; # the < person > tag is processed, no need to remember what it contained
},
);
$parser = XML::Rules- >new(rules = > @rules);
$parser- >parse( $xml);

Geo:Coder:US 1.00 offers a full-feature facility for geocoding US addresses, that is, estimating the latitude and longitude of any street address or intersection in the United States, using the TIGER/Line data set from the US Census Bureau. Geo:Coder:US uses Geo:TigerLine to parse this data, and DB_File to store a highly compressed distillation of it, and Geo:StreetAddress:US to parse addresses into normalized components suitable for looking up in its database.

You can find a live demo of this code at http://geocoder.us/. The demo.cgi script is included in eg/ directory distributed with this module, along with a whole bunch of other goodies. See Geo:Coder:US:Import for how to build your own Geo:Coder:US database.

Consider using a web service to access this geocoder over the Internet, rather than going to all the trouble of building a database yourself. See eg/soap-client.pl, eg/xmlrpc-client.pl, and eg/rest-client.pl for different examples of working clients for the rpc.geocoder.us geocoder web service.

Major Features:

1. Geo:Coder:US->geocode( $string )
   • Given a string containing a street address or intersection, return a list of specifiers including latitude and longitude for all matching entities in the database. To keep from churning over the entire database, the given address string must contain either a city and state, or a ZIP code (or both), or geocode() will return undef.
   • geocode() will attempt to normalize directional prefixes and suffixes, street types, and state abbreviations, as well as substitute TIGER/Line's idea of the "primary street name", if an alternate street name was provided instead.
   • If geocode() can parse the address, but not find a match in the database, it will return a hashref containing the parsed and normalized address or intersection, but without the "lat" and "long" keys specifying the location. If geocode() cannot even parse the address, it will return undef. Be sure to check for the existence of "lat" and "long" keys in the hashes returned from geocode() before attempting to use the values! This serves to distinguish between addresses that cannot be found versus addresses that are completely unparseable.
   • geocode() attempts to be as forgiving as possible when geocoding an address. If you say "Mission Ave" and all it knows about is "Mission St", then "Mission St" is what you'll get back. If you leave off directional identifiers, geocode() will return address geocoded in all the variants it can find, i.e. both "N Main St" and "S Main St".
   • Don't be surprised if geocoding an intersection returns more than one lat/long pair for a single intersection. If one of the streets curves greatly or doglegs even slightly, this will be the likely outcome.
   • geocode() is probably the method you want to use. See more in the following section on the structure of the returned address and intersection specifiers.
2. Geo:Coder:US->geocode_address( $string )
   • Works exactly like geocode(), but only parses addresses.
3. Geo:Coder:US->geocode_intersection( $string )
   • Works exactly like geocode(), but only parses intersections.
4. Geo:Coder:US->filter_ranges( $spec, @candidates )
   • Filters a list of address specifiers (presumably from the database) against a query specifier, filtering by prefix, type, suffix, or primary name if possible. Returns a list of matching specifiers. filter_ranges() will ignore a filtering step if it would result in no specifiers being returned. You probably won't need to use this.
5. Geo:Coder:US->find_ranges( $address_spec )
   • Given a normalized address specifier, return all the address ranges in the database that appear to cover that address. find_ranges() ignores prefix, suffix, and type fields in the specifier for search purposes, and then filters against them ex post facto. The intention for find_ranges() to find the closest match possible in preference to returning nothing. You probably want to use lookup_ranges() instead, which will call find_ranges() for you.
6. Geo:Coder:US->lookup_ranges( $address_spec, @ranges )
   • Given an address specifier and (optionally) some address ranges from the database, interpolate the street address into the street segment referred to by the address range, and return a latitude and longitude for the given address within each of the given ranges. If @ranges is not given, lookup_ranges() calls find_ranges() with the given address specifier, and uses those returned. You probably want to just use geocode() instead, which also parses an address string and determines whether it's a proper address or an intersection automatically.
7. Geo:Coder:US->find_segments( $intersection_spec )
   • Given a normalized intersection specifier, find all of the street segments in the database matching the two given streets in the given locale or ZIP code. find_segments() ignores prefix, suffix, and type fields in the specifier for search purposes, and then filters against them ex post facto. The intention for find_segments() to find the closest match possible in preference to returning nothing. You probably want to use lookup_intersection() instead, which will call find_segments() for you.
8. Geo:Coder:US->lookup_intersection( $intersection_spec )
   • Given an intersection specifier, return all of the intersections in the database between the two streets specified, plus a latitude and longitude for each intersection. You probably want to just use geocode() instead, which also parses an address string and determines whether it's a proper address or an intersection automatically.

Requirements: Perl

Monetra (formerly known as MCVE) is a scalable credit card processing engine for Linux and UNIX. The project is designed to handle credit card authorizations and is certified to support major clearing house protocols.
Features include support for multiple modems, multiple merchant accounts, and multiple processors, all simultaneously -- as well as IP and SSL connectivity along side SQL database support.
Designed in C, conforming to POSIX standards, and utilizing light weight processes (threads), this product is able to handle a large number of transactions with high speed and minimal CPU usage.
Enhancements:
- A secure recurring billing module and card storage subsystem returning unique tracking tokens has been added and branded as Monetra DSS.
- This assists integrators with their PCI compliance so they dont need to store card numbers outside of Monetra.
- There is DNS caching for improved latency.
- Givex and FifthThrid 610 support have been added.
- Global Payments, VITAL, and NPC re-certifications.
- Visa gift-card support (balance inquiry and partial auths), as well as new card systems compliance updates for October 2007.
- Mac OS X for Intel, Windows Vista, and OpenBSD 4.0 support has also been added.

Excalibur: Morganas Revenge (EMR) is a unique scenario based upon the Aleph One (Marathon) engine. It is a first-person action adventure game, featuring an epic and in-depth story line. As a Federation Marine resting after your last mission, you start aboard the exploration class Starship Kronos where you learn that your real mission has yet to begin. You are re-acquainted with the AI Merlin, who introduces you to Kronos time traveling technology, and reveals your new mission: to save mankind from the clutches of Morgana and her minions. Through untamed raptor-infested jungles, castle arenas, and war-torn streets of the future, you will wield weapons from all time periods - including the Sword of Power, Excalibur - in an effort to thwart the diabolical plot that unfolds. The EMR adventure, spread across 42 solo levels, weaves a tale of truth and honor, knighthood and bravery, and darkness and treachery. EMR also delivers 27 adrenaline pumped network levels. EMR immerses you in an amazing new world, creating an addictive, fun and unique gaming experience.

For those that played EMR under the old Marathon Infinity engine, EMR 3.0 brings exciting new maps, new high resolution textures and landscapes, a completely new set of weapons, new monsters and friends, new scenery, new 16-bit sounds, original music, and a carefully woven original story line that transcends time. Using the Aleph One engine, EMR now sports loads of new special features using Aleph Ones MML and Lua scripting languages. Please note that the AlephOne engine is old technology improved. Architecture is still simulated 3D, so there are no ramps, bridges, and balconies, nor horizontal doors. The sprites in EMR are made up of 2D images posed in different views, not 3D models. Do not expect the latest state-of-the-art graphics engine, but you can expect an intriguing storyline, creative map architectures, engaging graphics, original spellbinding music, and mood-setting sound effects.

Whats New in This Release:

• Levels with fog and mist
  
• Persistent effects such as poison, earthquakes, fire storm spell, and timed grenades
  
• Original MP3 music
  
• 12 unique weapons, including a new Dragon Flamer and T9000 Railgun
  
• New spells for your wand, including fire storm, teleportation, and raise the
  dead
  
• Beautifully rendered OpenGL textures and landscapes
  
• New graphics for Morgana, the Trex, raven, and Jurassic bug
  
• A huge variety of new hi-res scenery items
  
• New holodeck programs, including driving a Flintstone mobile through Bedrock!
  
• Blood Gulch style net map with 8 simulated net players and a huge battlefield
  
• A basketball court netmap where grenades in a basket win points for your team
  
• A beautiful new future level that lets you drive a Hoverbike!
  
• A total of 5 brand new solo maps and 4 new net maps
  
• Lots of updated maps with new areas, new tasks, new features, and new secrets
  
• New powerups, such as apples, bananas, health kits, emergency kits, and finally
  a use for all those magic scrolls!
  
• And much, much, more...
  

SYNOPPSIS

use LWP::Simple
use XML::Parser;
use XML::Parser::YahooRESTGeocode;

#connect to yahoo geocode service
my $url = http://api.local.yahoo.com/MapsService/V1/geocode;
my $get = appid=YahooDemo&street=701+First+Street&city=Sunnyvale&state=CA;

#call yahoo geocode service
my $xml = get $url . "?" . $get;

#construct use XML::Parser with YahooRESTGeocode subclass
my $parser = new XML::Parser(Style => YahooRESTGeocode);
my $data = $parser->parse($xml) || do {
die ("parse failed: $XML::Parser::errstr, $!n");
};

#use the data for something
my $cnt = 0;
foreach my $result (@{$data->{Result}}){
$cnt ++;
print "n---- RESULT #" . $cnt . " ----n";
foreach my $field (keys %{$result}){
print "t[" . $field . "]: " . $result->{$field} . "n";
}
}

NOTES

works for geocode only

this module only knows how to handle Yahoo!s REST responses from the geocode API

known fields

this module will need to be modified if more fields are added to the node, namely, their names will need to be added to the %node_tree hash at the top of the module

this was a quick hack

hey, maybe theres a better module for parsing REST query responses out there? This module was written as a quick hack, not as a one stop solution. If you want to add improvements or what have you, then please feel free to hack away on this till youre blue in the face. Send me the changes though, so I can put em in the distribution.

make test dosent really test anything

well ... its a quick hack. part of writing a quick hack is not writing proper test cases and skimping on documentation, speaking of ... why am I still writing ???

thanks to Yahoo!

Hey, Yahoo! Thanks for your geocode API, its pretty sweet!

PiX Frogger is a 4-player Frogger clone.
Your objective is to cross the street, and remember to look to both sides! Its really fun when four people play at the same time!
Main features:
- 4 players at the same time, in the same computer, with just the keyboard
- Compatible with Logitech Buzz controller!