NAME

Games::Roguelike::World::Daemon - roguelike game telnet daemon

SYNOPSIS

# for an extended example with move overrides, see the scripts/netgame included

use strict;

package myWorld;                                        # always override
use base 'Games::Roguelike::World::Daemon';

my $r = myWorld->new(w=>80,h=>50,dispw=>40,disph=>18);  # create a networked world
$r->area(new Games::Roguelike::Area(name=>'1'));        # create a new area in this world called "1"
$r->area->generate('cavelike');                         # make a cavelike maze

while (1) {
       $r->proc();
}

sub readinput {                                         # called when input is available
       my $self = shift;
       if (my $c = $self->getch()) {                    # returns undef on failure
               if ($self->{vp}->kbdmove($c, 1)) {       # '1' in second param means "test only"
                       $r->queuemove($self->{vp}, $c);  # if the move is good, queue it
               }
       }
}

sub newconn {                                           # called when someone connects
       my $self = shift;
       my $char = mychar->new($self->area(1),           # create a new character
               sym=>'@',
               color=>'green',
               pov=>7
       );
       $self->{vp} = $char;                             # viewpoint is a connection state obect
       $self->{state} = 'MOVE';                         # set state (another state object)
}

package mychar;
use base 'Games::Roguelike::Mob';

DESCRIPTION

This module uses the Games::Roguelike::World object as the basis for a finite-state based network game engine.

* uses Games::Roguelike::Console::ANSI library to draw the current area
* currently assumes Games::Roguelike::Mob's as characters in the game
* currently assumes Games::Roguelike::Item's as items in the game

The module provides th eservice of accepting connections, maintainting he association between the connection and a "state" and "viewpoint" for each connection, managing "tick" times, and rendering maps for each connection.

METHODS

new ()

Similar to ::World new, but with arguments: host, port, and addr

This begins listening for connections, and sets up some signal handlers for graceful death.

proc ()

Look for waiting input and calls:

newconn() - for new conneciton
readinput() - when input is available
tick() - to process per-turn moves
drawallmaps() - to render all the maps	

When those functions are called the class {vp} and {state} variables are set to the connection's "viewpoint" (character) and "state".

Also, the special scalar state 'QUIT' gracefully removes a connection.

(It might be interesting to use code refs as states)

getstr ()

Reads a string from the active connection.

Returns undef if the string is not ready.

getch ()

Reads a character from the active connection.

Returns undef if no input is ready.

charmsg ($char)

Calls showmsg on the console contained in $char;

readinput ()

Must override and call getch() or getstr().

The {vp}, {state}, and {con} vars are set on this call, can be changed, and will be preserved.

Actual action/movement by a charcter should be queued here, then processed according to a random sort and/or a sort based on the speed of the character.

For example: If a tank and a motorcycle move during the same tick, the motorcycle would always go first, even if the tank's player has a faster internet connection.  Queueing the moves allows you to do this.

Remember never to do something that blocks or waits for input, game is single-threaded.

newconn ()

Must override and either create a character or show an intro screen, or something.

The {vp}, {state}, and {con} vars are set on this call, can be changed, and will be preserved.

setfocuscolor ()

Change the display color/symbol of the {vp} character here in order to distinguish it from other (enemy?) characters.

queuemove ($char, $move[, $msg])

Pushes a "move" for char $char showing message $msg. By default will not queu if a move has been set. The "move" variabe is set in the "char" object to record whether a move has occured.

tick ()

Override for per-turn move processing. This is called for each game turn, which defaults to a half-second. Default behavior is to sort all the queued moves and execute them.

A good way to handle this might be to make the "moves" be code references, which get passed "char" as the argument.

BUGS

Currently this fails on Win32

SEE ALSO

Games::Roguelike::World

AUTHOR

Erik Aronesty earonesty@cpan.org

LICENSE

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

See http://www.perl.com/perl/misc/Artistic.html or the included LICENSE file.