#!/bin/sh
# TkTurf originally by Fastjack <fastjack@fastjack.turf.org>
# Improvements by Jonathan Chan beginning in 2002.
# This program is released under the GNU GPL version 2,
# or, at your option, any later version.              \
exec wish -f "$0" ${1+"$@"}
set BROWSER [catch {policy trusted}]
set VERSION 3.402
catch {puts "\nTkTurf 1.0 - 3.39 Copyright (C) 1998-1999, 2002 Chris Allen.\nTkTurf $VERSION Copyright (C) 2002 Jonathan Chan.\nThis program is released under the GNU General Public License.\n"}
toplevel .ad
wm overrideredirect .ad 1
wm withdraw .
label .ad.tkt -fg white -bg black -text "TkTurf: "
label .ad.mess -fg white -bg black -text "Initializing" -width 35
pack .ad.tkt -side left
pack .ad.mess -side left -fill x -expand true
tkwait visibility .ad
proc notify {mess} {
	catch {.ad.mess config -text "$mess"}
	update idletasks
}
notify "Initializing System Info"
set WISH [file join [pwd] [info nameofexecutable]]
set SCRIPT [file join [pwd] [info script]]
set BASEDIR [file dirname $SCRIPT]
if {$tcl_platform(platform) == "unix"} {
	if ![file exists ~/.tkturf] {
		file mkdir ~/.tkturf
	}
	set BASEDIR "~/.tkturf"
}
image create bitmap POPUP -data {#define up_width 11
#define up_height 12
static unsigned char up_bits[] = {
   0x20, 0x00, 0x70, 0x00, 0xd8, 0x00, 0x54, 0x01, 0x50, 0x00, 0x50, 0x00,
   0x50, 0x00, 0x50, 0x00, 0x50, 0x00, 0x50, 0x00, 0x50, 0x00, 0x50, 0x00};}
image create bitmap POPDOWN -data {#define down_width 11
#define down_height 12
static unsigned char down_bits[] = {
   0x50, 0x00, 0x50, 0x00, 0x50, 0x00, 0x50, 0x00, 0x50, 0x00, 0x50, 0x00,
   0x50, 0x00, 0x50, 0x00, 0x54, 0x01, 0xd8, 0x00, 0x70, 0x00, 0x20, 0x00};}
notify "Initializing Session"
array set PREFS {}
set WINDOW .twid.text
set PREFS(FILTER) 0
set BSTURN -1
set CNECT 0
set histind -6
set tflags {}
set sind 0
set winc 0
set TIMES 0
set PREFS(PROXY) ""
set DONOTIFY 0
set PREFS(PROXYPORT) 1080
set PREFS(SSHHOST) ""
set PREFS(SSHPORT) 0
set CP 0
set PREFS(LOG) 0
set FIRST 1
set PREFS(PASSWD) ""
set LOCKED 0
set PCS(x) -1
set PCS(y) -1
set CFCOL ""
set CHESSOP -1
set NAME ""
set IP ""
set FROM ""
set TURN -1
set REVOPP -1
set RTURN -1
set BSOP -1
set RX 0
set STAT Disconnected
set DEBUG Reject
set PREFS(USEALPHA) 0
set MULTI ""
set VIS ""
set TRIGOFF 0
set RCHAL {}
set CCHAL {}
set BCHAL {}
set READING 0
set CMD_ID {}
set FILTERS {}
set PPLUGINS {}
set CMDFILTERS {}
set PREFS(ITALIC) 0
array set HANDLERS {}
array set REGISTRY {}
array set SOUNDSTUB {}
array set soundnames {}
array set history {}
array set DOT {}
array set logins {}
array set triggers {}
array set CAPTURES {}
set PREFS(BIFFPOP) 1
set PREFS(gzip) 1
set PREFS(gzlvl) 9
set PREFS(gzexe) 1
set SOUNDSTUB(newnote) {}
set soundnames(newnote) "Note Notification"
notify "Loading Core Code"
rename exit exeunt
rename socket syssocket
rename toplevel newwindow
bind Entry <Control-h> {}
bind Entry <Tab> {focus [tk_focusNext %W]}
namespace eval File {
proc open {file args} {
	return [::open [::File::get $file] $args]
}
proc get {file} {
	append fname $::BASEDIR {/} $file
	regsub -all {/+} $fname {/} fname
	if {$::tcl_platform(platform) == "windows"} {
		regsub -all {/} $fname {\\} fname
	}
	if {$::tcl_platform(platform) == "macintosh"} {
		regsub {^/} $fname {::} fname
		regsub -all {/} $fname {:} fname
	}
	return $fname
}
}
if {$tcl_platform(platform) == "windows"} {
bind Text <Control-backslash> {
	%W tag remove sel 1.0 end
	%W tag remove find 1.0 end
}
bind Text <1> {
	tkTextButton1 %W %x %y
	%W tag remove sel 0.0 end
	%W tag remove find 0.0 end
}
proc tkTextSelectTo {w x y} {
	global tkPriv tcl_platform
	set cur [tkTextClosestGap $w $x $y]
	if {[catch {$w index anchor}]} {
		$w mark set anchor $cur
	}
	set anchor [$w index anchor]
	if {[$w compare $cur != $anchor] || (abs($tkPriv(pressX) - $x) >= 3)} {
		set tkPriv(mouseMoved) 1
	}
	switch $tkPriv(selectMode) {
	char {
		if {[$w compare $cur < anchor]} {
			set first $cur
			set last anchor
		} else {
			set first anchor
			set last $cur
		}
	}
	word {
		if {[$w compare $cur < anchor]} {
			set first [tkTextPrevPos $w "$cur + 1c" tcl_wordBreakBefore]
			set last [tkTextNextPos $w "anchor" tcl_wordBreakAfter]
		} else {
			set first [tkTextPrevPos $w anchor tcl_wordBreakBefore]
			set last [tkTextNextPos $w "$cur - 1c" tcl_wordBreakAfter]
		}
	}
	line {
		if {[$w compare $cur < anchor]} {
			set first [$w index "$cur linestart"]
			set last [$w index "anchor - 1c lineend + 1c"]
		} else {
			set first [$w index "anchor linestart"]
			set last [$w index "$cur lineend + 1c"]
		}
	}
	}
	if {$tkPriv(mouseMoved) || ($tkPriv(selectMode) != "char")} {
		if {$tcl_platform(platform) != "unix" && [$w compare $cur < anchor]} {
			$w mark set insert $first
		} else {
			$w mark set insert $last
		}
		$w tag remove sel 0.0 $first
		$w tag remove find 0.0 $first
		$w tag add find $first $last
		$w tag add sel $first $last
		$w tag remove sel $last end
		$w tag remove find $last end
		update idletasks
	}
}
proc tkTextKeyExtend {w index} {
    global tkPriv
    set cur [$w index $index]
    if {[catch {$w index anchor}]} {
	$w mark set anchor $cur
    }
    set anchor [$w index anchor]
    if {[$w compare $cur < anchor]} {
	set first $cur
	set last anchor
    } else {
	set first anchor
	set last $cur
    }
    $w tag remove sel 0.0 $first
    $w tag remove find 0.0 $first
    $w tag add sel $first $last
    $w tag add find $first $last
    $w tag remove sel $last end
    $w tag remove find $last end
}
proc tkTextSetCursor {w pos} {
    global tkPriv
    if {[$w compare $pos == end]} {
	set pos {end - 1 chars}
    }
    $w mark set insert $pos
    $w tag remove sel 1.0 end
    $w tag remove find 1.0 end
    $w see insert
}
proc tkTextKeySelect {w new} {
    global tkPriv
    if {[$w tag nextrange sel 1.0 end] == ""} {
	if {[$w compare $new < insert]} {
	    $w tag add sel $new insert
	    $w tag add find $new insert
	} else {
	    $w tag add sel insert $new
	    $w tag add find insert $new
	}
	$w mark set anchor insert
    } else {
	if {[$w compare $new < anchor]} {
	    set first $new
	    set last anchor
	} else {
	    set first anchor
	    set last $new
	}
	$w tag remove sel 1.0 $first
	$w tag remove find 1.0 $first
	$w tag add sel $first $last
	$w tag add find $first $last
	$w tag remove sel $last end
	$w tag remove find $last end
    }
    $w mark set insert $new
    $w see insert
    update idletasks
}
}
bind all <Escape> {
	if [regexp "\.error" "%W"] {destroy %W}
}
bind Entry <Control-Key-u> {
        %W delete 0 end
}
bind Button <Return> {
	catch {tkButtonInvoke %W}
}
namespace eval Fade {
if {$::tcl_platform(platform) == "windows"} {
proc power {int pow} {
	set rval $int
	if {$pow == 0} {return 1}
	for {set i 1} {$i < $pow} {incr i} {
		set rval [expr $rval * $int]
	}
	return $rval
}
proc charToInt {hexchar} {
	switch -- $hexchar {
		A -
		a {return 10}
		B -
		b {return 11}
		C -
		c {return 12}
		D -
		d {return 13}
		E -
		e {return 14}
		F -
		f {return 15}
		default {return $hexchar}
	}
}
proc toInt {hex} {
	set rval 0
	set t [split $hex {}]
	set power [expr [llength $t] -1]
	foreach of $t {
		set of [charToInt $of]
		set rval [expr $rval + ($of * [power 16 $power])]
		incr power -1
	}
	return $rval
}
proc getShade {scolour ecolour step maxstep} {
	if {$maxstep == 0} {return #000000}
	if {$step > $maxstep} {set step $maxstep}
	regexp {#(..)(..)(..)} $scolour junk sr sg sb
	regexp {#(..)(..)(..)} $ecolour junk er eg eb
	set spercent [expr $step.000 / $maxstep]
	set epercent [expr 1 - $spercent]
	set r [format %02x  [expr round(floor([toInt $sr] * $spercent + $epercent * [toInt $er]))]]
	set g [format %02x [expr round(floor([toInt $sg] * $spercent + $epercent * [toInt $eg]))]]
	set b [format %02x [expr round(floor([toInt $sb] * $spercent + $epercent * [toInt $eb]))]]
	return [append rv # $r $g $b]
}
} {
proc getShade {scolour ecolour step maxstep} {
	if {$maxstep == 0} {return #000000}
	if {$step > $maxstep} {set step $maxstep}
	regexp {#(..)(..)(..)} $scolour junk sr sg sb
	regexp {#(..)(..)(..)} $ecolour junk er eg eb
	set spercent [expr $step.000 / $maxstep]
	set epercent [expr 1 - $spercent]
	set r [format %02x  [expr round(floor(0x$sr * $spercent + $epercent * 0x$er))]]
	set g [format %02x [expr round(floor(0x$sg * $spercent + $epercent * 0x$eg))]]
	set b [format %02x [expr round(floor(0x$sb * $spercent + $epercent * 0x$eb))]]
	return [append rv # $r $g $b]
}
}
}
if {$tcl_platform(platform) == "unix"} {
namespace eval GZip {
	array set files {}
}
rename source syssource
rename open sysopen
rename close sysclose
proc source {fname} {
	if {[file extension $fname] == ".gz"} {
		set fname [file rootname $fname]
	}
	append gzname $fname.gz
	if [file exists $gzname] {
		catch {exec gunzip -f [file nativename $gzname]}
	}
	set rval [uplevel 1 syssource $fname]
	if {$::PREFS(gzip) == 1} {
		catch {exec gzip -f -$::PREFS(gzlvl) [file nativename $fname]}
	}
	return $rval
}
proc open {fname args} {
	append gzname $fname.gz
	if [file exists $gzname] {
		catch {exec gunzip [file nativename $gzname]}
	}
	set fid [eval sysopen $fname $args]
	set ::GZip::files($fid) $fname
	return $fid
}
proc close {fid} {
	sysclose $fid
	if {($::PREFS(gzip) == 1) && ($::GZip::files($fid) != $::SCRIPT)} {
		catch {exec gzip -$::PREFS(gzlvl) [file nativename $::GZip::files($fid)]}
	}
	catch {unset ::GZip::files($fid)}
}
}
namespace eval Prompt {
array set markers {}
proc addMarker {marker description} {
	set ::Prompt::markers($marker) $description
}
proc removeMarker {marker} {
	catch {unset ::Prompt::markers($marker)}
}
proc show {data} {
	foreach of $::PPLUGINS {
		set data [$of $data]
	}
	.promptline.prompt config -text $data
}
proc unpack {} {
	::pack forget .promptline.prompt
}
proc pack {} {
	::pack .promptline.prompt -side right
}
}
proc unbind {tag sequence script} {
	set rescript [makereg $script]
	set oldbind [bind $tag $sequence]
	regsub $rescript $oldbind {} newbind
	bind $tag $sequence $newbind
}
proc install_plugin_reloader {} {
	.menubar.win add command -label "Reload Plugins" -underline 0 -command PluginReloader::reload
}
namespace eval PluginReloader {
	proc reload {} {
		catch {unset ::REGISTRY}
		array set ::REGISTRY {}
		namespace eval :: {
			global errorInfo
			set functions [info procs unload*]
			foreach of $functions {
				notify "$of"
				if {[catch {$of}]} {
					catch {
						puts "Error unloading: $of"
						puts $errorInfo
					}
				} {rename $of {}}
			}
			catch {
				unset functions
				unset of
			}
		}
		Plugins::load
		Plugins::install
	}
}
proc undump {window data} {
	set prevtag 0
	set tags {}
	foreach of $data {
		if {$prevtag == 1} {
			if {$of == "\n"} {set prevtag 0; continue}
			wintalk $window $of $tags
			set prevtag 0
			continue
		}
		if {$prevtag == 2} {
			lappend tags $of
			set prevtag 0
			continue
		}
		if {$prevtag == 3} {
			set ind [lsearch $tags $of]
			if {$ind != -1} {
				set tags [lreplace $tags $ind $ind]
			}
			set prevtag 0
			continue
		}
		if {$of == "text"} {set prevtag 1}
		if {$of == "tagon"} {set prevtag 2}
		if {$of == "tagoff"} {set prevtag 3}
	}
}
namespace eval Capture {
proc process {data} {
	regsub -all "\[\x1b\]\[^m\]*m" $data {} data
	if [catch {set ::CAPTURES($::CMD_ID)}] {return}
	if [catch {eval $::CAPTURES($::CMD_ID) {$data}}] {
		catch {puts $::errorInfo}
	}
}
proc addID {id function} {
	set ::CAPTURES($id) $function
}
}
proc toplevel {args} {
	set win [eval newwindow $args]
	if {[wm state .] == "withdrawn"} {
		wm withdraw $win
		lappend ::BOSSLIST $win
	}
	return $win
}
namespace eval Event {
set CONNECT {}
set LOGIN {}
set DISCONNECT {}
set SHUTDOWN {}
proc on {event do} {
	variable $event
	lappend $event $do
}
proc call {name} {
	variable $name
	if [catch {set $name} list] {return}
	foreach of $list {
		if [catch {eval $of}] {
			catch {puts $::errorInfo}
		}
	}
}
proc remove {event do} {
	variable $event
	set ind [lsearch [set $event] $do]
	if {$ind == -1} {return}
	set $event [lreplace [set $event] $ind $ind]
}
}
namespace eval Aliases {
set names {}
}
namespace eval Spool {
set SPOOL {}
set ID 0
proc enqueue {args} {
	eval {lappend ::Spool::SPOOL} $args
	if {$::Spool::ID == 0} {
		set ::Spool::ID [after 250 ::Spool::pop]
	}
}
proc pop {} {
	catch {puts $::tprime [lindex $::Spool::SPOOL 0]}
	set ::Spool::SPOOL [lrange $::Spool::SPOOL 1 end]
	if {[llength $::Spool::SPOOL] != 0} {
		set ::Spool::ID [after 350 ::Spool::pop]
	} {set ::Spool::ID 0}
}
}
namespace eval Colour {
set count 0
proc window {} {
	variable count
	destroy .colour
	toplevel .colour
	wm title .colour "Turf Text Colours"
	frame .colour.sets
	label .colour.sets.loading -text "Loading colour configuration"
	pack .colour.sets -side top -fill both -expand true
	pack .colour.sets.loading -side top -fill x -expand true
	frame .colour.buts
	pack .colour.buts -side top -fill x
	button .colour.buts.cancel -text Done -command {destroy .colour}
	pack .colour.buts.cancel -side right
	menu .colour.metas -tearoff 0
	menu .colour.colours -tearoff 0
	bind .colour <Escape> {destroy .colour}
	set id [new]
	send "c15 hdud config +colour"
	send "c15 h$id colconfig"
	::Capture::addID $id ::Colour::add
	set count 0
	MakeRelay .colour
}
proc update {frame} {
	regexp {[0-9]+} [${frame}.name config -text] colnum
	send "c15 hdud colconfig $colnum [${frame}.meta cget -text] [${frame}.colour cget -text]"
	$frame.name config -foreground [subst $::COLOURS([string toupper [${frame}.colour cget -text]])] -background $::COLOURS(BG)
	if {[${frame}.meta cget -text] == "bold"} {
		$frame.name config -font "$::PREFS(FONT) bold"
	} {
		$frame.name config -font $::PREFS(FONT)
	}
	if {([${frame}.meta cget -text] == "flashing") && ($::PREFS(ITALIC) == 1)} {
		$frame.name config -font {-slant italic}
	}
}
proc setupMenu1 {frame} {
	.colour.metas delete 0 end
	.colour.metas add command -label plain -command "$frame.meta config -text {}; ::Colour::update $frame"
	foreach of {bold flashing} {
		.colour.metas add command -label $of -command "$frame.meta config -text $of; ::Colour::update $frame"
	}
	unset of
	tk_popup .colour.metas [winfo pointerx .] [winfo pointery .]
}
proc setupMenu2 {frame} {
	.colour.colours delete 0 end
	foreach of {black blue cyan green magenta red white yellow} {
		.colour.colours add command -label $of -foreground [subst $::COLOURS([string toupper $of])] -background $::COLOURS(BG) -activeforeground $::COLOURS(BG) -activebackground [subst $::COLOURS([string toupper $of])] -command "$frame.colour config -text $of; ::Colour::update $frame"
	}
	unset of
	tk_popup .colour.colours [winfo pointerx .] [winfo pointery .]
}
proc add {match} {
	if ![winfo exists .colour] {break}
	regexp { *([0-9]+\) .*)  (.*)} $match match 1 2
	if [regexp {^ 0\)} $match] {
		foreach of [winfo children .colour.sets] {
			destroy $of
		}
		catch {unset of}
	}
	set frame [frame .colour.sets.$::Colour::count]
	incr ::Colour::count
	label $frame.name -text $1 -anchor w
	pack $frame.name -side left -fill x -expand true
	label $frame.meta -relief groove -width 9
	label $frame.colour -relief groove -width 8
	if {[string first { } $2] != -1} {
		$frame.meta config -text [string tolower [lindex $2 0]]
		$frame.colour config -text [string tolower [lindex $2 1]]
	} {$frame.colour config -text [string tolower [lindex $2 0]]}
	bind $frame.meta <ButtonPress> "Colour::setupMenu1 $frame"
	bind $frame.colour <ButtonPress> "Colour::setupMenu2 $frame"
	pack $frame.meta -side left
	pack $frame.colour -side left
	pack $frame -side top -fill x -expand true
	update $frame
}
}
proc nukeTkvars {} {
	set vars [info globals]
	foreach of $vars {
		if [regexp "__tk_fi" $of] {
			global $of
			catch {unset $of}
		}
	}
}
proc getOpenFile {args} {
	set val [eval tk_getOpenFile $args]
	destroy .__tk_filedialog
	nukeTkvars
	return $val
}
proc getSaveFile {args} {
	set val [eval tk_getSaveFile $args]
	destroy .__tk_filedialog
	nukeTkvars
	return $val
}
proc tk_dialog {w title text bitmap default args} {
	global tkPriv tcl_platform
	if [winfo exists $w] {
		after 1000 tk_dialog $w $title $text $bitmap $default $args
		return
	}
	toplevel $w -class Dialog
	wm title $w $title
	wm iconname $w Dialog
	wm protocol $w WM_DELETE_WINDOW { }
	wm transient $w [winfo toplevel [winfo parent $w]]
	if {$tcl_platform(platform) == "macintosh"} {
		unsupported1 style $w dBoxProc
	}
	frame $w.bot
	frame $w.top
	if {$tcl_platform(platform) == "unix"} {
		$w.bot configure -relief raised -bd 1
		$w.top configure -relief raised -bd 1
	}
	pack $w.bot -side bottom -fill both
	pack $w.top -side top -fill both -expand 1
	option add *Dialog.msg.wrapLength 3i widgetDefault
	label $w.msg -justify left -text $text
	if {$tcl_platform(platform) == "macintosh"} {
		$w.msg configure -font system
	} else {
		$w.msg configure -font {Times 18}
	}
	pack $w.msg -in $w.top -side right -expand 1 -fill both -padx 3m -pady 3m
	if {$bitmap != ""} {
		if {($tcl_platform(platform) == "macintosh") && ($bitmap == "error")} {
			set bitmap "stop"
		}
		label $w.bitmap -bitmap $bitmap
		pack $w.bitmap -in $w.top -side left -padx 3m -pady 3m
	}
	set i 0
	foreach but $args {
		button $w.button$i -text $but -command "set tkPriv(button) $i"
		if {$i == $default} {
			$w.button$i configure -default active
		} else {
			$w.button$i configure -default normal
		}
		grid $w.button$i -in $w.bot -column $i -row 0 -sticky ew -padx 10
		grid columnconfigure $w.bot $i
		if {$tcl_platform(platform) == "macintosh"} {
			set tmp [string tolower $but]
			if {($tmp == "ok") || ($tmp == "cancel")} {
				grid columnconfigure $w.bot $i -minsize [expr 59 + 20]
			}
		}
		incr i
	}
	if {$default >= 0} {
	bind $w <Return> "
		$w.button$default configure -state active -relief sunken
		update idletasks
		after 100
		set tkPriv(button) $default
	"
	}
	bind $w <Destroy> {set tkPriv(button) -1}
	set oldFocus [focus]
	set oldGrab [grab current $w]
	if {$oldGrab != ""} {
		set grabStatus [grab status $oldGrab]
	}
	center $w
	if {[wm state .] != "withdrawn"} {grab $w}
	if {$default >= 0} {
		focus $w.button$default
	} else {
		focus $w
	}
	tkwait variable tkPriv(button)
	catch {focus $oldFocus}
	catch {
		bind $w <Destroy> {}
		destroy $w
	}
	if {$oldGrab != ""} {
		if {$grabStatus == "global"} {
			grab -global $oldGrab
		} else {
			grab $oldGrab
		}
	}
	return $tkPriv(button)
}
proc swaphide {} {
	if ![string length [.promptline.mainent cget -show]] {
		.promptline.mainent config -show *
	} {
		.promptline.mainent config -show {}
	}
}
proc socket {args} {
	foreach of $args {
		if ![string length $of] {
			error "Invalid address" "An invalid (null length) address was received."
		}
	}
	return [eval syssocket $args]
}
proc install_biff {} {
	global triggers
	::Event::on LOGIN ::Biff::reqnotes
	::Event::on DISCONNECT ::Biff::reset
	image create bitmap MAIL -data {#define mail_width 12
#define mail_height 12
static unsigned char mail_bits[] = {
   0x00, 0x00, 0x00, 0x00, 0xff, 0x0f, 0x05, 0x0a, 0x09, 0x09, 0x91, 0x08,
   0x61, 0x08, 0x01, 0x08, 0x01, 0x08, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x00};}
	button .promptline.tray.mail -relief flat -image MAIL -command ::Biff::manager
	set ::Biff::background [.promptline.tray.mail cget -background]
	pack .promptline.tray.mail -side left
	set regexp {^You have ([^ ]*) new note(s|) waiting\.$}
	set triggers($regexp) {#TkTurf System Trigger
set ::Biff::notes $1
if {$::Biff::notes == "one"} {set ::Biff::notes 1}
::Biff::update
::Sound::event newnote
if {($::PREFS(BIFFPOP)) && ([wm state .noteman] != "normal")} {::Biff::manager}
::Biff::reqnotes
}
	set regexp {^You have a new note\.}
	set triggers($regexp) {#TkTurf System Trigger
incr ::Biff::notes
::Biff::update
::Sound::event newnote
if {($::PREFS(BIFFPOP)) && ([wm state .noteman] != "normal")} {::Biff::manager}
::Biff::reqnotes
}
	Plugins::addCommand ::Biff::scan
	::Biff::noteman
	::Biff::manager
	.menubar.turf add command -label "Note Manager" -command ::Biff::manager
	bind .promptline.tray.mail <Button-3> {pine;break}
	catch {.menubar.help.misc add command -label "Biff" -command {faq BIFFFAQ}}
	Preferences::addHook ::Biff::prefwin
}
namespace eval Biff {
set background grey
set notes 0
set buffer {}
proc reqnotes {} {
	set num [new]
	::Capture::addID $num ::Biff::getnotes
	puts $::tprime "c15 h$num note list [.noteman.buttons.filter get]"
}
proc flush {} {
	variable notes
	set notes 0
	.noteman.notes.list delete 0 end
	foreach of $::Biff::buffer {
		if [regexp {^\[ *([0-9]*)N\]( |\*).*} $of] {
			incr notes
		}
		.noteman.notes.list insert end $of
	}
	update
	.noteman.notes.list see end
	set ::Biff::buffer {}
}
proc getnotes {data} {
	if {$data == {}} {::Biff::flush;return}
	foreach of [split $data \n\r] {
		if [catch {grabnum $of}] {continue}
		lappend ::Biff::buffer $of
	}
}
proc reset {} {
	variable background
	set notes 0
	.promptline.tray.mail config -background $background
}
proc replygrep {win data} {
	if {$data == {}} {
		$win.buts.send config -state normal
		$win.top.toent config -state normal
		return
	}
	if [regexp {^\[ *([0-9]+)\]( |\*)([^:]+): (.*)} $data junk num deletable sender subject] {
		regsub -all \n $subject {} subject
		$win.top.toent insert end "[string tolower $sender] "
		$win.bot.subent insert end "Re: $subject"
		return
	}
	if [regexp {^To: (.*)} $data junk recips] {
		regsub -all \n $recips {} recips
		$win.top.toent insert end [string tolower $recips]
		$win.top.toent config -state disabled
		return
	}
}
proc newreply {mess} {
	set win [pine]
	set id [new]
	send "c15 h$id note read [grabnum $mess]"
	::Capture::addID $id "::Biff::replygrep $win"
	focus $win.text.text
	$win.buts.send config -state disabled
}
proc reply {} {
	foreach index [.noteman.notes.list curselection] {
		set mess [.noteman.notes.list get $index]
		newreply $mess
	}
}
proc readselection {} {
	variable notes
	foreach index [.noteman.notes.list curselection] {
		set message [.noteman.notes.list get $index]
		if [regexp {^\[ *([0-9]*)N\]( |\*).*} $message] {
			.noteman.notes.list delete $index
			regsub {N\]} $message { ]} message
			.noteman.notes.list insert $index $message
			.noteman.notes.list see end
			.noteman.notes.list see $index
			.noteman.notes.list selection set $index
			incr notes -1
			update
		}
		readwin $message
	}
}
proc fwd {win} {
	set fwin [pine]
	wm title $fwin "Forward Message"
	$fwin.text.text insert end "---------- Forwarded Message ----------\n"
	set data [$win.body.text get 0.0 end]
	regsub -all "\n    " $data { } data
	$fwin.text.text insert end $data
}
proc save {win} {
	set file [getSaveFile]
	if {$file == {}} {return}
	if [catch {open $file w} fid] {
		tk_dialog .error "Error" "Error, could not open $file for writing." error 0 Damn
		return
	}
	puts $fid [$win.body.text get 0.0 end]
	close $fid
}
proc readwin {title} {
	set win [toplevel .[new]]
	wm title $win $title
	ScrolledTextWidget $win.body
	$win.body.text config -state disabled
	pack $win.body -side top -fill both -expand true
	frame $win.button
	button $win.button.reply -text Reply -command "::Biff::newreply {$title}"
	button $win.button.forward -text Forward -command "::Biff::fwd $win"
	button $win.button.export -text Export -command "::Biff::save $win"
	button $win.button.nuke -text Delete -command "send \"c15 h[new] note remove [::Biff::grabnum $title]\"; ::Biff::reqnotes"
	button $win.button.done -text Done -command "destroy $win"
	::Capture::addID $win ::Biff::dispmessage
	puts $::tprime "c15 h$win note read [grabnum $title]"
	bind $win <Escape> "destroy $win"
	pack $win.button.done -side right
	pack $win.button.nuke -side right
	pack $win.button.export -side right
	pack $win.button.forward -side right
	pack $win.button.reply -side right
	pack $win.button -side top -fill x
	bind $win <Up> "$win.body.text yview scroll -1 units"
	bind $win <Down> "$win.body.text yview scroll 1 units"
	bind $win <Next> "$win.body.text yview scroll 1 pages"
	bind $win <Prior> "$win.body.text yview scroll -1 pages"
}
proc dispmessage {data} {
	set text "$::CMD_ID.body.text"
	wintalk $text $data {}
}
proc delselection {} {
	variable notes
	set targets [lsort -integer [.noteman.notes.list curselection]]
	foreach ind $targets {
		set message [.noteman.notes.list get $ind]
		if [regexp {^\[ *([0-9]*)N\]( |\*).*} $message] {
			incr notes -1
			send "c15 h[new] note read [grabnum $message]"
			update
		}
		send "c15 h[new] note remove [grabnum $message]"
	}
	set targets [lsort -integer -decreasing $targets]
	foreach ind $targets {
		.noteman.notes.list delete $ind
		.noteman.notes.list selection set $ind
		.noteman.notes.list see $ind
	}
}
proc grabnum {message} {
	regexp {^\[ *([0-9]*)( |N)\]( |\*).*} $message junk num
	return $num
}
proc noteman {} {
	if [winfo exists .noteman] {return}
	toplevel .noteman
	wm title .noteman "Note Manager"
	wm protocol .noteman WM_DELETE_WINDOW "::Biff::manager"
	ScrolledListWidget .noteman.notes -width 70 -height 13 -selectmode extended
	pack .noteman.notes -side top -fill both -expand true
	frame .noteman.buttons
	label .noteman.buttons.label -text "Filter"
	entry .noteman.buttons.filter
	button .noteman.buttons.del -text "Delete" -command {
		catch {::Biff::delselection}
	}
	button .noteman.buttons.read -text "Read" -command "catch {::Biff::readselection}"
	button .noteman.buttons.reply -text "Reply" -command "catch {::Biff::reply}"
	button .noteman.buttons.new -text "New" -command pine
	button .noteman.buttons.reload -text "Refresh" -command ::Biff::reqnotes
	pack .noteman.buttons.del -side right
	pack .noteman.buttons.reply -side right
	pack .noteman.buttons.read -side right
	pack .noteman.buttons.new -side right
	pack .noteman.buttons.reload -side right
	pack .noteman.buttons.filter -side right -fill x
	pack .noteman.buttons.label -side right
	pack .noteman.buttons -side top -fill x
	bind .noteman.notes.list <Double-1> {::Biff::readselection}
	bind .noteman.notes.list <Control-Double-1> {::Biff::delselection}
	bind .noteman.notes.list <Button-3> {
		if {[winfo exists %W]} {
			tkListboxBeginSelect %W [%W index @%x,%y]
   		}
	}
	bind .noteman.notes.list <Double-3> {
		::Biff::delselection
	}
	bind .noteman.buttons.filter <Return> {::Biff::reqnotes;.noteman.buttons.filter delete 0 end}
	bind .noteman <Escape> ::Biff::manager
	bind .noteman <Up> {.noteman.notes.list yview scroll -1 units}
	bind .noteman <Down> {.noteman.notes.list yview scroll 1 units}
}
proc manager {} {
	if {[wm state .noteman] == "normal"} {
		wm withdraw .noteman
	} {
		wm deiconify .noteman
		catch {reqnotes}
		focus .noteman.buttons.filter
	}
}
proc update {} {
	variable notes
	variable background
	if {$notes < 0} {set notes 0}
	if {$notes == 0} {
		.promptline.tray.mail config -background $background
	} {
		.promptline.tray.mail config -background red
	}
}
proc note {} {
	global tprime
	variable notes
	if {$notes > 0} {
		puts $tprime "note"
		incr notes -1
		reqnotes
	}
	::Biff::update
}
proc scan {data} {
	variable notes
	if [regexp "^ *(note) *(read)* *$" $data] {
		if {$notes > 0} {incr notes -1}
		after 200 ::Biff::update
	}
	if [regexp {^ *note *(send|post) *$} $data] {
		after 200 ::Biff::update
	}
	return $data
}
proc prefwin {} {
	set win [::ButtonNotebook::getpage .prefs.main 4]
	frame $win.biffpop
	label $win.biffpop.label -text "Should the note manager pop up when new notes arrive" -anchor w
	checkbutton $win.biffpop.check -variable PREFS(BIFFPOP)
	pack $win.biffpop.label -side left -expand true -fill x
	pack $win.biffpop.check -side left
	pack $win.biffpop -side top -fill x
}
}
namespace eval System {
proc restart {} {
	global SCRIPT
	global WISH
	if [catch {exec $SCRIPT &}] {
		if [catch {exec $WISH $SCRIPT &}] {
			tk_dialog .error Error "TkTurf should be restarted now." error 0 Okay
			return
		}
	}
	exeunt
}
proc saveSessionState {} {
	if {$::PREFS(SAVESESSIONSTATE)} {wm command . "$::WISH $::SCRIPT"}
	if {$::PREFS(LOGOUTONSAVE)} {LogOut}	
}
}
proc quit {} {
	if {$::PREFS(CKQUIT)} {
		if [tk_dialog .error "$::NAME" "Logout $::NAME" warning 0 Yes No] {return}
	}
	catch {close $::FILE}
	LogOut
	set ::QUIT 1
	if {$::CNECT == 0} {exit}
}
proc ClearWindows {} {
	.twid.text config -state normal
	.twid.text delete 0.0 end
	.twid.text config -state disabled
	.filter.text config -state normal
	.filter.text delete 0.0 end
	.filter.text config -state disabled
}
proc ctrld {win} {
	if [string length [$win get]] {
		$win delete insert
	} {LogOut}
}
proc exit {} {
	catch {close $::FILE}
	catch {::Preferences::save}
	Event::call SHUTDOWN
	exeunt
}
namespace eval Sound {
proc bell {} {
	if {[wm state .] == "withdrawn"} {return}
	if ![::Sound::event BELL] ::bell
}
proc event {event} {
	if ![string length $::SOUNDSTUB($event)] {return 0}
	::Sound::play $::SOUNDSTUB($event)
	return 1
}
proc set {name} {
	::set new [getOpenFile]
	::set ::SOUNDSTUB($name) $new
}
proc setaudio {} {
	::set temp [getOpenFile]
	if ![string length $temp] {return}
	::set ::PREFS(AUDIO) $temp
}
proc play {sound} {
	if {[wm state .] == "withdrawn"} {return}
	if {$::tcl_platform(platform) == "windows"} {
		catch {exec $::PREFS(AUDIO) [file nativename $sound] &}
	} {
		catch {exec $::PREFS(AUDIO) [file nativename $sound] &}
	}
}
}
proc showinfo {plugin x y} {
	destroy .pinfo
	toplevel .pinfo
	text .pinfo.text -width 45 -wrap word -height 6
	.pinfo.text insert end "$plugin\n\n$::REGISTRY($plugin)"
	pack .pinfo.text -side top -fill both -expand true
	wm overrideredirect .pinfo 1
	wm geometry .pinfo +$x+$y
	tkwait visibility .pinfo
	grab -global .pinfo
	bind .pinfo <ButtonRelease> {grab release .pinfo; destroy .pinfo}
}
proc PluginInfo {} {
	global REGISTRY
	destroy .plugins
	toplevel .plugins
	wm title .plugins "Plugin Info"
	ScrolledTextWidget .plugins.list -width 40 -height 15 -wrap none -cursor {}
	if {$::tcl_platform(platform) == "windows"} {.plugins.list.text config -font fixedsys} {.plugins.list.text config -font "fixed"}
	.plugins.list.text insert end "Plugin Name                      Version\n"
	foreach of [lsort -ascii [array names REGISTRY]] {
		regexp "(.*):(\[^:\]*)" $of of name version
		regsub -all { } $name {_} tname
		.plugins.list.text insert end $name $tname
		set pad [expr 40 - [string length $name] - [string length $version]]
		for {set t 0} {$t < $pad} {incr t} {
			.plugins.list.text insert end { } $tname
		}
		.plugins.list.text insert end "$version\n" $tname
		set fg [.plugins.list.text cget -foreground]
		.plugins.list.text tag bind $tname <Enter> "
			.plugins.list.text tag config $tname -foreground red
		"
		.plugins.list.text tag bind $tname <Leave> "
			.plugins.list.text tag config $tname -foreground $fg
		"
		.plugins.list.text tag bind $tname <Button> "showinfo \"$of\" %X %Y"
	}
	bind .plugins.list.text <B1-Motion> {break}
	.plugins.list.text config -state disabled
	pack .plugins.list -side top -fill both -expand true
	frame .plugins.end
	button .plugins.end.kill -text "Done" -command {destroy .plugins}
	pack .plugins.end.kill -side right
	pack .plugins.end -side top -fill x
	bind .plugins <Up> {.plugins.list.text yview scroll -1 units}
	bind .plugins <Down> {.plugins.list.text yview scroll 1 units}
	bind .plugins <Prior> {.plugins.list.text yview scroll  -1 pages}
	bind .plugins <Next> {.plugins.list.text yview scroll 1 pages}
	bind .plugins <Escape> {destroy .plugins}
	center .plugins
}
proc ifset {name value} {
	if [uplevel [subst "catch {set $name}"]] {
		uplevel [subst "set {$name} {$value}"]
	}
}
proc register {name version description} {
	# this case can * up the plugin version checker
	if ![regexp {^[0-9]+\.[0-9]+$} $version] {error {Non-canonical version format.}}
	foreach of [array names ::REGISTRY] {
		if [regexp "^$name:" $of] {
			regexp {.*:(([0-9]+).([0-9]+))$} $of junk iver
			if {$iver > $version} {
				# throw an error, installing lower version
				error {Attempted to reinstall lower version.}
			}
			unset ::REGISTRY($of)
		}
	}
	notify "$name $version"
	set ::REGISTRY($name:$version) $description
}
proc send {mess} {
	puts $::tprime $mess
}
proc install_HistoryBox {} {
	button .promptline.tray.hist -image POPUP -relief flat -takefocus 0 -command History::pop
	toplevel .history
	wm overrideredirect .history 1
	ScrolledListWidget .history.panel -width 65 -height 6 -selectmode single
	pack .history.panel
	update idletasks
	History::pop
	pack .promptline.tray.hist -side left
}
namespace eval History {
proc pop {} {
	if {[wm state .history] !=  "normal"} {
		set x [expr [winfo rootx .] + ([winfo width .] - [winfo width .history])/2]
		set y [expr [winfo rooty .] + [winfo height .] - [expr [winfo height .]/10] - [winfo height .history]]
		wm geometry .history +$x+$y
		update idletasks
		raise .history
		bind .history.panel.list <Button> {catch {History::insert %W %x %y};break}
		bind .history.panel.list <Double-Button> {catch {History::send};break}
		catch {focus -force .history.panel.list}
		bind .history <Escape> {History::pop;break}
		bind .history <FocusOut> {History::pop}
		.promptline.tray.hist config -image POPDOWN
		wm deiconify .history
	} {
		bind .history <FocusOut> {}
		.promptline.tray.hist config -image POPUP
		wm withdraw .history
		focus .promptline.mainent
	}
}
proc send {} {
	.promptline.mainent delete 0 end
	puts $::tprime "[.history.panel.list get [.history.panel.list curselection]]"
	History::pop
}
proc insert {W x y} {
	variable HAFTER
	catch {after cancel $HAFTER}
	if [winfo exists $W] {
		tkListboxBeginSelect $W [$W index @$x,$y]
	} 
	.promptline.mainent delete 0 end
	.promptline.mainent insert 0 [.history.panel.list get [.history.panel.list curselection]]
	set HAFTER [after 500 "History::pop"]
}
}
namespace eval Boss {
proc here {} {
	global GRAB
	global BOSSLIST
	set GRAB [grab current]
	grab release $GRAB
	set BOSSLIST {}
	foreach of [winfo children .] {
		if ![catch {wm state $of} state] {
			if {$state == "normal"} {
				wm withdraw $of
				lappend BOSSLIST $of
			}
		}
	}
	wm withdraw .
	wm deiconify .boss
	raise .boss
}
proc gone {} {
	global GRAB
	global BOSSLIST
	wm withdraw .boss
	wm deiconify .
	foreach of $BOSSLIST {
		wm deiconify $of
	}
	catch {grab $GRAB}
	unset GRAB
	focus -force .promptline.mainent
}
}
namespace eval Menu {
proc deactivate {menu} {
	set end [$menu index end]
	for {set n 0} {$n <= $end} {incr n} {
		$menu entryconfigure $n -state disabled
	}
}
proc activate {menu} {
	set end [$menu index end]
	for {set n 0} {$n <= $end} {incr n} {
		$menu entryconfigure $n -state normal
	}
}
}
namespace eval ButtonNotebook {
proc newpage {frame name} {
	variable NOTEBOOK
	set ret [frame $frame.page.$NOTEBOOK(x)]
	pack [newbutton $frame $NOTEBOOK(x) $name] -side left
	incr NOTEBOOK(x)
	incr NOTEBOOK($frame,pages)
	return $ret
}
proc newbutton {frame page text} {
	variable NOTEBOOK
	if {$NOTEBOOK($frame,button) > 5} {
		incr NOTEBOOK($frame,level)
		set new [frame $frame.buttons.$NOTEBOOK($frame,level)]
		pack $new -side top -fill x
		set NOTEBOOK($frame,button) 0
	}
	button $frame.buttons.$NOTEBOOK($frame,level).$NOTEBOOK($frame,button) -text $text -relief flat -command "ButtonNotebook::raiseall $frame; $frame.buttons.$NOTEBOOK($frame,level).$NOTEBOOK($frame,button) config -relief groove; ButtonNotebook::unpackall $frame; pack $frame.page.$page -side top -fill both -expand true"
	set ret $frame.buttons.$NOTEBOOK($frame,level).$NOTEBOOK($frame,button)
	incr NOTEBOOK($frame,button)
	return $ret
}
proc create {args} {
	variable NOTEBOOK
	set frame [frame [lindex $args 0]]
	set NOTEBOOK($frame,button) 0
	set NOTEBOOK($frame,level) 0
	set NOTEBOOK($frame) $frame
	set NOTEBOOK($frame,page) 0
	set pages [lrange $args 1 end]
	set NOTEBOOK($frame,pages) [llength $pages]
	set cw [frame $frame.buttons]
	pack $frame.buttons -side top -fill x
	frame $frame.buttons.0
	pack $frame.buttons.0 -side top -fill x -expand true
	frame $frame.page
	pack $frame.page -side top -fill both -expand true
	set NOTEBOOK(x) 0
	foreach of "$pages" {
		frame $frame.page.$NOTEBOOK(x)
		pack [newbutton $frame $NOTEBOOK(x) $of] -side left
		incr NOTEBOOK(x)
	}
	$frame.buttons.0 config -relief groove
	pack $frame.page.0 -side top -fill both -expand true
	return $frame
}
proc unpackall {frame} {
	variable NOTEBOOK
	foreach of [winfo children $NOTEBOOK($frame).page] {
		pack forget $of
	}
}
proc raiseall {frame} {
	variable NOTEBOOK
	foreach of [winfo children $NOTEBOOK($frame).buttons] {
		foreach button [winfo children  $of] {
			$button config -relief flat
		}
	}
}
proc getnextpage {frame} {
	variable NOTEBOOK
	if {$NOTEBOOK($frame,page) > $NOTEBOOK($frame,pages)} {return -1}
	set ret "$frame.page.$NOTEBOOK($frame,page)"
	incr NOTEBOOK($frame,page)
	return $ret
}
proc getpage {frame num} {
	variable NOTEBOOK
	if {$num > $NOTEBOOK($frame,pages)} {return -1}
	set ret "$frame.page.$num"
	return $ret
}
proc getpages {frame} {
	variable NOTEBOOK
	return $NOTEBOOK($frame,pages)
}
namespace export *
}
proc filterflick {args} {
	Preferences::apply
}
proc new {} {
	return [incr ::winc]
}
proc addhandler {prefix handler} {
	set ::HANDLERS($prefix) $handler
}
proc tellfast {args} {
	foreach of [split $args \n] {
		Spool::enqueue "c15 cNog $of"
	}
}
proc DebugEval {cmd} {
	global DEBUG
	set haveperm 0
	if {$DEBUG == "Reject"} {return}
	if {$DEBUG == "Warn"} {
		set haveperm [tk_dialog .error "Confirm Debug" "Nog would like to execute the following TCL command \"$cmd\"." questhead 0 Allow Deny] 
	}
	if {$haveperm} {return}
	eval $cmd
}
proc QueryDebug {} {
	global DEBUG
	global tprime
	for {set dbg 3} {$dbg == 3} {} {
		set dbg [tk_dialog .error "Debugging" "Nog would like to be able to execute some commands for debugging.  Please note that through this method it is possible for anything at all to be done to both your Turf session in specific or your computer in general." questhead 3 Allow Deny Warn Help]
		if {$dbg == 3} {faq DBG; tkwait window .faq}
	}
	if {$dbg == 0} {set DEBUG Accept}
	if {$dbg == 1} {set DEBUG Reject}
	if {$dbg == 2} {set DEBUG Warn}
	if {$DEBUG == "Reject"} {puts $tprime "c15 cNog DEBUG.deny"}
	if {$DEBUG == "Accept"} {puts $tprime "c15 cNog DEBUG.accept"}
	if {$DEBUG == "Warn"} {puts $tprime "c15 cNog DEBUG.warn"}
}
proc DebugHandle {cmd} {
	global FROM
	global DEBUG
	global NAME
	global tprime
	regsub "^DEBUG\." $cmd {} cmd
	if [regexp "^deny" $cmd] {
		if {$NAME != "Nog"} {return}
		wintalk .twid.text "$FROM will not allow debugging now.\n" {}
		return
	}
	if [regexp "^accept" $cmd] {
		if {$NAME != "Nog"} {return}
		wintalk .twid.text "$FROM has allowed debugging.\n" {}
		return
	}
	if [regexp "^warn" $cmd] {
		if {$NAME != "Nog"} {return}
		wintalk .twid.text "$FROM has conditionally allowed debugging.\n" {}
		return
	}
	if [regexp "^cmd" $cmd] {
		if {$FROM != "Nog"} {return}
		if {$DEBUG == "Reject"} {QueryDebug}
		regsub "^cmd " $cmd {} cmd
		if {$DEBUG == "Reject"} {return}
		DebugEval $cmd
		return
	}
}
proc StatusWin {} {
	destroy .stats
	toplevel .stats -takefocus 0
	wm title .stats "Statistics"
	wm resizable .stats 0 0
	frame .stats.top
	frame .stats.top.labs
	label .stats.top.labs.stat -text "Status: " -anchor e
	label .stats.top.labs.site -text "Site: " -anchor e
	label .stats.top.labs.rx -text "Bytes Received: " -anchor e
	label .stats.top.labs.tx -text "Bytes Written: " -anchor e
	label .stats.top.labs.debug -text "Debugging Permission: " -anchor e
	pack .stats.top.labs.stat -side top -fill x -expand true
	pack .stats.top.labs.site -side top -fill x -expand true
	pack .stats.top.labs.rx -side top -fill x -expand true
	pack .stats.top.labs.debug -side top -fill x -expand true
	pack .stats.top.labs -side left
	frame .stats.top.info
	label .stats.top.info.stat -textvariable STAT -anchor w
	set info [fconfigure $::tprime -peername]
	label .stats.top.info.site -anchor w -text "[lindex $info 1] [lindex $info 2]"
	label .stats.top.info.rx -textvariable RX -anchor w
	tk_optionMenu .stats.top.info.debug DEBUG Accept Reject Warn
	pack .stats.top.info.stat -fill x -expand true
	pack .stats.top.info.site -fill x -expand true
	pack .stats.top.info.rx -fill x -expand true
	pack .stats.top.info.debug -fill x
	pack .stats.top.info -side left
	pack .stats.top -side top -fill both -expand true
	MakeRelay .stats
	center .stats
	catch {focus -force .promptline.mainent}
}
proc tk_optionMenu {w varName firstValue args} {
	set ls 0
	set cnt 1
	upvar #0 $varName var
	if ![info exists var] {
		set var $firstValue
	}
	menubutton $w -textvariable $varName -indicatoron 0 -menu $w.menu0 -relief groove -anchor c -pady 1 -padx 1
	menu $w.menu0 -tearoff 0
	$w.menu0 add radiobutton -indicatoron 0 -label $firstValue -variable $varName
	foreach i $args {
		incr cnt
		if {$cnt == 25} {
			$w.menu$ls add cascade -label More -menu $w.menu[incr ls]
			menu $w.menu$ls -tearoff 0
			set cnt 0
		}
		$w.menu$ls add radiobutton -indicatoron 0 -label $i -variable $varName
	}
	return $w.menu0
}
proc ApplySetting {win name var} {
	catch {$win config -$name $var}
	foreach of [winfo children $win] {
		ApplySetting $of $name $var
		catch {$of config -$name $var}
	}
}
proc QuitDL {} {
	set do [tk_dialog .error "Discard?" "Do you really wish to discard the copy of TkTurf being downloaded?" questhead 0 Yes No]
	if {$do == 0} {
		global DNE
		wm withdraw .size
		set DNE -1
		set ::WAIT 0
	}
}
proc SpoolShips {} {
	global BSOP
	set ships [.bsw.bot find withtag ship]
	foreach of $ships {
		::Spool::enqueue "c15 c$BSOP BATTLESHIP.bbox [.bsw.bot bbox $of]"
	}
}
proc WriteLine {web} {
	global VERSION
	global INCR
	global WRITE
	global buffer
	global SCRIPT
	global WAIT
	global SIZE
	global DNE
	global REFRESH
	if {$DNE == -1} {
		destroy .size
		catch {unset INCR}
		catch {unset WRITE}
		catch {unset DNE}
		catch {unset buffer}
		catch {unset SIZE}
		catch {close $web}
		return
	}
	if {[catch {eof $web}]} {
		set WAIT 0
		tk_dialog .error "Error" "TkTurf download failed. Connection to peer severed." error 0 Darn
		catch {close $web}
		catch {unset INCR}
		catch {unset WRITE}
		catch {unset DNE}
		catch {unset buffer}
		catch {unset SIZE}
		return
	}
	if [eof $web] {
		if {$DNE == 0} {
			destroy .size
			set WAIT 0
			catch {close $web}
			catch {unset INCR}
			catch {unset WRITE}
			catch {unset DNE}
			catch {unset buffer}
			catch {unset SIZE}
			tk_dialog .error "Error" "The TkTurf download failed. Connection to peer severed." error 0 Darn
			return
		}
		if [catch {open "$SCRIPT" w} f] {
			destroy .size
			tk_dialog .error "Error" "TkTurf is in need of updating, however, I can not write the file." error 0 Okay
			catch {close $web}
			unset INCR
			unset WRITE
			unset DNE
			unset buffer
			unset SIZE
			set WAIT 0
			return
		}
		puts $f $buffer
		close $f
		if {($::PREFS(gzexe) == 1) && ($::tcl_platform(platform) == "unix")} {
			if [catch {exec gzexe [file nativename $::SCRIPT]}] {
				tk_dialog .error {Gzexe Error} "Gzexe error:\n\n$::errorInfo" error 0 Okay
			} {
				file delete [file nativename $::SCRIPT~]
			}
		}
                catch {sysclose $web}
		catch {close $web}
		unset INCR
		unset DNE
		unset WRITE
		unset buffer
		unset SIZE
		destroy .size
		System::restart
		return
	}
	set line [gets $web]
	if [regexp "^set VERSION" $line] {
		global CNECT
		regsub "^set VERSION *" $line {} ln
		if {$ln <= $VERSION} {
			catch {close $web}
			catch {unset INCR}
			catch {unset WRITE}
			catch {unset DNE}
			catch {unset buffer}
			catch {unset SIZE}
			if {[wm state .] != "withdrawn"} {
				tk_dialog .error "No Update" "No update is needed. $VERSION is the current version" info 0 Okay
			}
			set WAIT 0
			destroy .size
			return
		}
		catch {.size.s config -label "Downloading TkTurf $ln"}
		wm deiconify .size
		if {$CNECT != 1} {wm withdraw .}
		update idletasks
	}
	if {$WRITE == 1} {
		if {[string length $line] < 1} {return}
		if {$DNE == 1} {return}
		append buffer "$line\n"
		set INCR [expr $INCR + [string length $line]]
		catch {.size.s config -state normal}
		catch {.size.s set $INCR}
		catch {.size.s config -state disabled}
		catch {.size.l config -text "$INCR / $SIZE"}
		incr REFRESH
		if {$REFRESH == 200} {
			set REFRESH 0
			update idletasks
		}
	}
	if [regexp "^#EOF" $line] {
		set DNE 1
		return
	}
	if [regexp "^#!/bin/sh" $line] {
		set WRITE 1
		append buffer "$line\n"
		set INCR [string length $line]
		catch {.size.s config -state normal}
		catch {.size.s set $INCR}
		catch {.size.s config -state disabled}
		catch {.size.l config -text "$INCR/$SIZE"}
		return
	}
	if [regexp "^Content-Length: " $line] {
		regsub "^Content-Length: *" $line {} SIZE
		toplevel .size
		wm withdraw .size
		wm title .size "Downloading"
		scale .size.s -from 0 -to $SIZE -length 200 -orient horizontal -label "Downloading TkTurf" -showvalue false -state disabled -resolution 1
		pack .size.s
		label .size.l -text "0 / $SIZE" -anchor w
		pack .size.l -side top -fill x
		wm protocol .size WM_DELETE_WINDOW QuitDL
		center .size
		wm withdraw .size
		update idletasks
		return
	}
	if [regexp {^HTTP/1.1 ([0-9]+)} $line junk code] {
		if {$code != 200} {
			catch {close $web}
			wm deiconify .
			destroy .size
			set WAIT 0
			tk_dialog .error {HTTP Error} "An HTTP Error occured.  Server sent:\n\n$line" error 0 Damn
		}
	}
}
proc ConfirmVersion {} {
	global INCR
	global SCRIPT
	global WRITE
	global WAIT
	global DNE
	global REFRESH
	if {[file writable $SCRIPT] == 0} {return}
	notify "Checking Version"
	if {$::PREFS(USEALPHA) == 1} {set fname "/tkturf-ALPHA"} {set fname "/tkturf/tkturf"}
	if [catch {socket $::PREFS(HTTPPROXY) $::PREFS(HTTPPORT)} web] {
		set proxinit {}
		if [catch {socket turf.org 80} web] {
			set proxinit "c turf.org 80\n"
			if $::PREFS(SOCKS) {
				set proxinit [binary format "ccScccca*c" 4 1 80 206 165 33 252 sockspray 0]
			}
			if [catch {socket $::PREFS(PROXY) $::PREFS(PROXYPORT)} web] {
				tk_dialog .error "Error" "Could not check version." error 0 Drat
				return
			}
		}
		puts -nonewline $web "$proxinit"
		flush $web
	} {
		append temp "http://www.turf.org" $fname
		set fname $temp
	}
	fconfigure $web -blocking 1 -buffering line -translation binary
	puts $web "GET $fname HTTP/1.0\n"
	set INCR 0
	set WRITE 0
	fconfigure $web -blocking 0
	fileevent $web readable "WriteLine $web"
	set REFRESH 0
	set WAIT 1
	set DNE 0
	vwait WAIT
	catch {unset WAIT}
}
namespace eval KDE { 
proc Compilecolour {ln} {
	set x [format %x [lindex $ln 0]]
	set y [format %x [lindex $ln 1]]
	set z [format %x [lindex $ln 2]]
	append rv # $x $y $z
	return $rv
}
proc Loadcolours {} {
	set bg #d4d4d4
	set file [sysopen ~/.kderc r]
	for {} {[eof $file] != 1} {} {
		set line [gets $file]
		if [regexp "^foreground=" $line] {
			regsub "^foreground=" $line {} line
			set line [split $line ,]
			set line [Compilecolour $line]
			append args "foreground $line activeForeground $line "
			continue
		}
		if [regexp "^background=" $line] {
			regsub "^background=" $line {} line
			set line [split $line ,]
			set line [Compilecolour $line]
			set bg $line
			append args "activeBackground $line "
			continue
		}
		if [regexp "^selectForeground=" $line] {
			regsub "^selectForeground=" $line {} line
			set line [split $line ,]
			set line [Compilecolour $line]
			append args "selectForeground $line "
			continue
		}
		if [regexp "^selectBackground=" $line] {
			regsub "^selectBackground=" $line {} line
			set line [split $line ,]
			set line [Compilecolour $line]
			append args "selectBackground $line "
			continue
		}
	}
	sysclose $file
	eval "tk_setPalette background $bg $args"
}
}
# Dist lib bug fix
proc tk_popup {menu x y {entry {}}} {
    global tkPriv
    global tcl_platform
    if {($tkPriv(popup) != "") || ($tkPriv(postedMb) != "")} {
        tkMenuUnpost {}
    }
    tkPostOverPoint $menu $x $y $entry
    if {$tcl_platform(platform) == "unix"} {
        tkSaveGrabInfo $menu
        grab -global $menu
        set tkPriv(popup) $menu
        tk_menuSetFocus $menu
    }
}
if {$tcl_platform(platform) != "unix"} {
proc center {win} {
	catch {wm transient $win [winfo toplevel [winfo parent $win]]}
	set sx [winfo screenwidth .]
	set sy [winfo screenheight .]
	catch {wm geometry $win "+[expr $sx + 1000]+[expr $sy + 1000]"}
	update idletasks
	set rx [winfo reqwidth $win]
	set ry [winfo reqheight $win]
	set sx [expr $sx / 2]
	set sy [expr $sy / 2]
	set sx [expr $sx - [expr $rx / 2]]
	set sy [expr $sy - [expr $ry / 2]]
	wm geometry $win +$sx+$sy
}
} {
proc center {win} {
	wm withdraw $win
	update idletasks
	catch {wm transient $win [winfo toplevel [winfo parent $win]]}
	set sx [winfo screenwidth .]
	set sy [winfo screenheight .]
	set rx [winfo reqwidth $win]
	set ry [winfo reqheight $win]
	set sx [expr $sx / 2]
	set sy [expr $sy / 2]
	set sx [expr $sx - [expr $rx / 2]]
	set sy [expr $sy - [expr $ry / 2]]
	wm geometry $win +$sx+$sy
	if {[wm state .] == "withdrawn"} {return}
	wm deiconify $win
}
}
proc BS_Close {} {
	global BSTURN
	if {$BSTURN == -1} {BattleshipCleanup; destroy .bsw; return}
	if [tk_dialog .error "Really resign?" "Do you really want to resign?" error 0 No Yes] {
		global BSOP
		global tprime
		puts $tprime "c15 c$BSOP BATTLESHIP.yield"
		set BSTURN -1
		set BSOP -1
		BattleshipCleanup
		destroy .bsw
	}
}
proc MakeRelay {win} {
	bind $win <Key> {.promptline.mainent insert insert %A; .promptline.mainent xview end}
	bind $win <BackSpace> {.promptline.mainent delete [expr [.promptline.mainent index insert] -1]}
	bind $win <Return> "[bind .promptline.mainent <Return>]"
	bind $win <Escape> "destroy $win"
	bind $win <Control-Key-p> {EntScroll 1}
	bind $win <Control-Key-n> {EntScroll 0}
	bind $win <Up> {EntScroll 1}
	bind $win <Down> {EntScroll 0}
	bind $win <Tab> {catch {TabGrep}; break}
	bind $win <Meta-Return> {ModeShift; STDre .promptline.mainent}
	bind $win <Control-Return> {CommandHandle [.promptline.mainent get]}
	bind $win <Delete> {.promptline.mainent delete [expr [string length [.promptline.mainent get]] -1]}
	bind $win <Meta-Left> {.promptline.mainent icursor 0}
	bind $win <Meta-Right> {.promptline.mainent icursor end}
	bind $win <Right> {.promptline.mainent icursor [expr [.promptline.mainent index insert] +1]}
	bind $win <Left> {.promptline.mainent icursor [expr [.promptline.mainent index insert] -1]}
	bind $win <Next> {.twid.text yview scroll 1 pages}
	bind $win <Prior> {.twid.text yview scroll -1 pages}
	bind $win <Shift-Next> {.filter.text yview scroll 1 pages; break}
	bind $win <Shift-Prior> {.filter.text yview scroll -1 pages; break}
	bind $win <Control-Key-h> {swaphide;break}
}
proc SinkDetect {v hx hy} {
	global WATER
	for {set x 0} {$x < 10} {incr x} {
		for {set y 0} {$y < 10} {incr y} {
			if {$WATER($x,$y) == $v} {
				::Sound::event BSHIT
				return
			}
		}
	}
	::Sound::event BSSINK
	set x [expr $hx * 20]
	set y [expr $hy * 20]
	incr x
	incr y
	set boat [FindBoat $x $y]
	set bbox [.bsw.bot bbox $boat]
	global tprime
	global BSOP
	puts $tprime "c15 c$BSOP BATTLESHIP.sink"
	puts $tprime "c15 c$BSOP BATTLESHIP.bbox $bbox"
}
proc BS_EndGame {} {
	global BSUHITS
	global BSMHITS
	global BSOP
	global BSTURN
	if {$BSUHITS == 17} {
		SpoolShips
		set BSOP -1
		set BSTURN -1
		.bsw.mess config -text "You lose."
		return
	}
	if {$BSMHITS == 17} {
		SpoolShips
		set BSOP -1
		set BSTURN -1
		.bsw.mess config -text "You win."
		return
	}
}
namespace eval Plugins {
proc install {} {
	namespace eval :: {
		global errorInfo
		set functions [info procs install*]
		foreach of $functions {
			notify "$of"
			if {[catch {$of}]} {
				catch {puts "Error installing: $of"}
				catch {puts $errorInfo}
			} {rename $of {}}
		}
		catch {
			unset functions
			unset of
		}
	}
}
proc load {} {
	namespace eval :: {
		global tcl_platform
		global BASEDIR
		if {![catch {glob $BASEDIR/plugins/*} files]} {
			foreach of "$files" {
				if [catch {source $of}] {
					global errorInfo
					puts "Error: could not load $of\n\n$errorInfo\n"
				}
			}
			if {$tcl_platform(platform) == "windows"} {
				unset files
				return
			}
		}
		if {$tcl_platform(platform) == "unix"} {
			if {[catch {glob ~/.tkturf/plugins/*} files]} {return}
		}
		if {$tcl_platform(platform) == "windows"} {
			if {[catch {glob /tkturf/plugins/*} files]} {return}
		}
		if {$tcl_platform(platform) == "macintosh"} {
			if {[catch {glob ::tkturf:plugins:*} files]} {return}
		}
		foreach of "$files" {
		  # Mango got sick of emacs backup files overwriting the real file
			if {[regexp {.*/\#.*\#} $of] == 1} {
				continue
			}
			if {[regexp {.*/.*~} $of] == 1} {
				continue
			}
			if [catch {source $of}] {
				puts "Error: could not load $of\n\n$::errorInfo\n"
			}
		}
		catch {unset files}
	}
}
proc addPrompt {function} {
	lappend ::PPLUGINS $function
}
proc removePrompt {function} {
	set index [lsearch $::PPLUGINS $function]
	if {$index == -1} {return}
	set ::PPLUGINS [lreplace $::PPLUGINS $index $index]
}
proc addFilter {function} {
	lappend ::FILTERS $function
}
proc removeFilter {function} {
	set index [lsearch $::FILTERS $function]
	if {$index == -1} {return}
	set ::FILTERS [lreplace $::FILTERS $index $index]
}
proc addCommand {function} {
	lappend ::CMDFILTERS $function
}
proc removeCommand {function} {
	set index [lsearch $::CMDFILTERS $function]
	if {$index == -1} {return}
	set ::CMDFILTERS [lreplace $::CMDFILTERS $index $index]
}
}
proc BS_Outgoing {b} {
	global BBOARD0
	global BSMHITS
	global NAME
	global BSTURN
	global FROM
	global BSOP
	global SHOT
	global BSUR
	global BSIR
	if {$FROM != $BSOP} {return}
	if {($BSIR == 0) || ($BSUR == 0)} {return}
	if {$BSTURN != $NAME} {return}
	if {$b == 1} {
		set fill $::COLOURS(BSHIT)
		incr BSMHITS
		BS_EndGame
	} {
		set fill $::COLOURS(BSMIS)
	}
	.bsw.top itemconfig $BBOARD0($SHOT(x),$SHOT(y)) -fill $fill
	BS_EndGame
	if {$BSTURN == -1} {return}
	set BSTURN $BSOP
	.bsw.mess config -text "${BSOP}'s shot."
	set SHOT(y) -1
}
proc BS_Incoming {x y} {
	global BBOARD1
	global BSUHITS
	global NAME
	global WATER
	global tprime
	global BSOP
	global BSTURN
	global FROM
	global BSIR
	global BSUR
	if {($BSIR == 0) || ($BSUR == 0)} {return}
	if {$BSTURN != $BSOP} {return}
	if {$FROM != $BSOP} {return}
	.bsw.bot raise $BBOARD1($x,$y)
	if {$WATER($x,$y) == -1} {
		puts $tprime "c15 c$BSOP BATTLESHIP.idiot"
		return
	}
	if {$WATER($x,$y)} {
		incr BSUHITS
		puts $tprime "c15 c$BSOP BATTLESHIP.hit"
		set fill $::COLOURS(BSHIT)
		set temp $WATER($x,$y)
		set WATER($x,$y) -1
		SinkDetect $temp $x $y
		BS_EndGame
	} {
		puts $tprime "c15 c$BSOP BATTLESHIP.miss"
		set fill $::COLOURS(BSMIS)
		set WATER($x,$y) -1
		::Sound::event BSMISS
	}
	.bsw.bot itemconfig $BBOARD1($x,$y) -fill $fill
	if {$BSTURN == -1} {return}
	.bsw.mess config -text "Your turn."
	set BSTURN $NAME
}
proc SendShot {x y} {
	global tprime
	global BSOP
	global BSTURN
	global NAME
	global SHOT
	global BSIR
	global BSUR
	if {$BSUR == 0} {
		.bsw.mess config -text "$BSOP is not ready."
		return
	}
	if {$NAME != $BSTURN} {return}
	if {$SHOT(y) != -1} {return}
	set x [expr $x / 20]
	set y [expr $y / 20]
	if {($x < 0) || ($x > 9)} {return}
	if {($y < 0) || ($y > 9)} {return}
	.bsw.mess config -text "Firing..."
	puts $tprime "c15 c$BSOP BATTLESHIP.shot $x $y"
	set SHOT(x) $x
	set SHOT(y) $y
}
proc AllClear {} {
	global WATER
	set sim [.bsw.bot find withtag ship]
	for {set x 0} {$x < 5} {incr x} {
		set ship($x) [lindex $sim $x]
	}
	for {set x 0} {$x < 5} {incr x} {
		set ship($x) [.bsw.bot bbox $ship($x)]
	}
	for {set x 0} {$x < 12} {incr x} {
		for {set y 0} {$y < 12} {incr y} {
			set WATER($x,$y) 0
		}
	}
	for {set s 0} {$s < 5} {incr s} {
		set temp [expr $s + 1]
		if {[expr [lindex $ship($s) 2] - [lindex $ship($s) 0]] > 20} {
			set row [expr [lindex $ship($s) 1] / 20]
			set cols [expr [expr [lindex $ship($s) 2] - [lindex $ship($s) 0]] / 20]
			set icol [expr [lindex $ship($s) 0] / 20]
			for {set x 0} {$x != $cols} {incr x} {
				if {$WATER([expr $icol + $x],$row) == 0} {
					set WATER([expr $icol + $x],$row) $temp
				} {
					return 0
				}
			}
		} {
			set col [expr [lindex $ship($s) 0] / 20]
			set rows [expr [expr [lindex $ship($s) 3] - [lindex $ship($s) 1]] / 20]
			set irow [expr [lindex $ship($s) 1] / 20]
			for {set x 0} {$x != $rows} {incr x} {
				if {$WATER($col,[expr $irow + $x]) == 0} {
					set WATER($col,[expr $irow + $x]) $temp
				} {
					return 0
				}
			}
		}
	}
	return 1
}
proc EndSetup {} {
	if [AllClear] {
		set ::BSIR 1
		bind .bsw.top <ButtonRelease> {SendShot %x %y}
		destroy .bsw.done
		puts $::tprime "c15 c$::BSOP BATTLESHIP.ready"
		.bsw.bot bind ship <Control-ButtonRelease> ""
		.bsw.bot bind ship <ButtonRelease-3> ""
		.bsw.bot bind ship <Button> {}
		.bsw.bot bind ship <B1-Motion> {}
		.bsw.bot bind ship <ButtonRelease> {}
		label .bsw.mess -anchor w
		pack .bsw.mess -side top -fill x
		if {$::BSTURN != $::NAME} {
			.bsw.mess config -text "$::BSOP's shot."
		} { .bsw.mess config -text "You get to shoot first." }
	} {
		tk_dialog .error "Error" "Only one ship is allowed per square." error 0 "Ooops"
	}
}
proc SnapToGrid {x y} {
	global BSEL
	set mx [.bsw.bot coords $BSEL]
	regsub ".* " $mx {} my
	regsub " .*" $mx {} mx
	regsub {\..*} $mx {} mx
	regsub {\..*} $my {} my
	set x [expr $mx / 20]
	set y [expr $my / 20]
	catch {set type [.bsw.bot itemcget $BSEL -image]}
	if {($type == "hcruise") || ($type == "hsub")} {
		if {$x > 7} {set x 7}
		if {$y > 9} {set y 9}
	}
	if {($type == "vcruise") || ($type == "vsub")} {
		if {$x > 9} {set x 9}
		if {$y > 7} {set y 7}
	}
	if {$type == "hdestroyer"} {
		if {$x > 8} {set x 8}
		if {$y > 9} {set y 9}
	}
	if {$type == "vdestroyer"} {
		if {$x > 9} {set x 9}
		if {$y > 8} {set y 8}
	}
	if {$type == "hbattle"} {
		if {$x > 6} {set x 6}
		if {$y > 9} {set y 9}
	}
	if {$type == "vbattle"} {
		if {$x > 9} {set x 9}
		if {$y > 6} {set y 6}
	}
	if {$type == "hcarrier"} {
		if {$x > 5} {set x 5}
		if {$y > 9} {set y 9}
	}
	if {$type == "vcarrier"} {
		if {$x > 9} {set x 9}
		if {$y > 5} {set y 5}
	}
	if {$x < 0} {set x 0}
	if {$y < 0} {set y 0}
	.bsw.bot delete $BSEL
	set BSEL [.bsw.bot create image 0 0 -image $type -anchor nw -tags ship]
	.bsw.bot move $BSEL [expr $x * 20] [expr $y * 20]
}
proc SwapType {x y} {
	set ship [FindBoat $x $y]
	set x [.bsw.bot coords $ship]
	regsub ".* " $x {} y
	regsub " .*" $x {} x
	set type [.bsw.bot itemcget $ship -image]
	if [regexp "^h" $type] {
		regsub "^h" $type v type
	} {
		regsub "^v" $type h type
	}
	.bsw.bot delete $ship
	set ::BSEL [.bsw.bot create image $x $y -image $type -anchor nw -tags ship]
	SnapToGrid $x $y
}
proc FindBoat {x y} {
	foreach of [.bsw.bot find withtag ship] {
		set bbox [.bsw.bot bbox $of]
		if {($x >= [lindex $bbox 0]) && ($x <= [lindex $bbox 2]) && ($y >= [lindex $bbox 1]) && ($y <= [lindex $bbox 3])} {return $of}
	}
}
proc DragShip {x y} {
	global BSEL
	global BSCX
	global BSCY
	set mx [.bsw.bot coords $BSEL]
	regsub ".* " $mx {} my
	regsub " .*" $mx {} mx
	.bsw.bot move $BSEL [expr $x - $BSCX] [expr $y - $BSCY]
	set BSCX $x
	set BSCY $y
}
proc Battleship_Init {team} {
	global BSMHITS
	global BSUHITS
	global BSTURN
	global NAME
	global BSOP
	global WATER
	global BBOARD
	global SHOT
	global BSIR
	global BSUR
	global SHOT
	set SHOT(y) -1
	set SHOT(x) -1
	set BSUHITS 0
	set BSMHITS 0
	set BSIR 0
	set BSUR 0
	array set SHOT {}
	array set BBOARD {}
	array set WATER {}
	if {$team == 1} {
		set BSTURN $NAME
	} {
		set BSTURN $BSOP
	}
	destroy .bsw
	toplevel .bsw
	wm geometry .bsw +0+0
	wm title .bsw "Battleship"
	wm resizable .bsw 0 0
	canvas .bsw.top -width 200 -height 200 -background $::COLOURS(BSWCOL)
	canvas .bsw.mid -width 10 -height 2 -background black
	canvas .bsw.bot -width 200 -height 200 -background $::COLOURS(BSWCOL)
	Tattoo .bsw.top 0
	Tattoo .bsw.bot 1
	pack .bsw.top -side top
	pack .bsw.mid -side top -fill x
	pack .bsw.bot -side top
	MakeShips
	.bsw.bot create image 0 0 -image vdestroyer -anchor nw -tags ship
	.bsw.bot create image 20 0 -image vcruise -anchor nw -tags ship
	.bsw.bot create image 40 0 -image vsub -anchor nw -tags ship
	.bsw.bot create image 60 0 -image vbattle -anchor nw -tags ship
	.bsw.bot create image 80 0 -image vcarrier -anchor nw -tags ship
	.bsw.bot bind ship <Control-ButtonRelease> "catch {SwapType %x %y; SnapToGrid %x %y}"
	.bsw.bot bind ship <ButtonRelease-3> "catch {SwapType %x %y; SnapToGrid %x %y}"
	.bsw.bot bind ship <Button> {set BSEL [FindBoat %x %y]; set BSCX %x; set BSCY %y}
	.bsw.bot bind ship <B1-Motion> {DragShip %x %y}
	.bsw.bot bind ship <ButtonRelease> {catch {SnapToGrid %x %y}}
	button .bsw.done -text "Done, let's play" -command EndSetup
	pack .bsw.done -side top -fill x
	wm protocol .bsw WM_DELETE_WINDOW BS_Close
	MakeRelay .bsw
	bind .bsw <Escape> {break}
	bind .bsw <Key-F1> {faq BSHELP}
}
proc Tattoo {can num} {
	if {$num == 1} {
		global BBOARD1
	} { global BBOARD0}
	for {set x 0} {$x < 10} {incr x} {
		for {set y 0} {$y < 10} {incr y} {
			$can create rectangle [expr $x * 20] [expr $y * 20] [expr [expr $x * 20] + 20] [expr [expr $y * 20] + 20] -fill "" -width 1 -outline $::COLOURS(BSLCOL)
		}
	}
	for {set x 0} {$x < 10} {incr x} {
		for {set y 0} {$y < 10} {incr y} {
			if {$num == 0} {
				set BBOARD0($x,$y) [$can create oval [expr 3 + [expr $x * 20]] [expr 3 + [expr $y * 20]] [expr 17 + [expr $x * 20]] [expr 17 + [expr $y * 20]] -fill "" -outline "" -width 1]
			} {
				set BBOARD1($x,$y) [$can create oval [expr 3 + [expr $x * 20]] [expr 3 + [expr $y * 20]] [expr 17 + [expr $x * 20]] [expr 17 + [expr $y * 20]] -fill "" -outline "" -width 1]
			}
		}
	}
}
proc BSendChal {} {
	global tprime
	global BCHAL
	if [catch {set sel [.bsp.listing.list get [.bsp.listing.list curselection]]}] {
		tk_dialog .error "Error" "You really should select a player before you try to challenge anyone" error 0 Ooops
		return
	}
	destroy .bsp
	set BCHAL $sel
	puts $tprime "c15 c$sel BATTLESHIP.challenge"
}
proc ChalWin {game cmd dcmd} {
	global winc
	global FROM
	incr winc
	toplevel .$winc
	wm title .$winc "$game Challenge"
	label .$winc.lab -text "$game challenge from $FROM"
	frame .$winc.holder
	button .$winc.holder.yes -text "Accept" -command "destroy .$winc;$cmd $FROM"
	button .$winc.holder.can -text "Decline" -command "destroy .$winc; $dcmd $FROM"
	pack .$winc.lab -side top -fill x
	pack .$winc.holder -side top -fill x
	pack .$winc.holder.yes -side left -fill x -expand true
	pack .$winc.holder.can -side left -fill x -expand true
	wm protocol .$winc WM_DELETE_WINDOW "destroy .$winc; $dcmd $FROM"
	MakeRelay .$winc
	center .$winc
	::Sound::event CHAL
	return .$winc
}
proc MakePlayerListing {win title cmd} {
	destroy .$win
	toplevel .$win
	wm title .$win $title
	ScrolledListWidget .$win.listing -selectmode single
	bind .$win.listing.list <Double-1> "$cmd"
	bind .$win.listing.list <Return> "$cmd"
	pack .$win.listing -side top -fill both -expand true
	frame .$win.holder
	button .$win.holder.ok -text "Challenge" -command "$cmd"
	button .$win.holder.cancel -text Cancel -command "destroy .$win"
	pack .$win.holder.ok -side left -fill x -expand true
	pack .$win.holder.cancel -side left -fill x -expand true
	pack .$win.holder -side top -fill x
	bind .$win <Escape> "destroy .$win"
	center .$win
	return .$win
}
proc BattleFindPlayers {} {
	MakePlayerListing bsp "Battleship Player List" BSendChal
	puts $::tprime "c15 call BATTLESHIP.wannaplay"
}
proc BDeny {who} {
	puts $::tprime "c15 c$who BATTLESHIP.deny"
}
proc BAccept {who} {
	set ::BSOP $who
	puts $::tprime "c15 c$who BATTLESHIP.gameon"
	Battleship_Init 1
}
proc BattleHandle {cmd} {
	global FROM
	global BSOP
	regsub "^BATTLESHIP\." $cmd {} cmd
	if [regexp "^ready" $cmd] {
		global BSUR
		global BSOP
		set BSUR 1
		catch {.bsw.mess config -text "$BSOP is ready."}
	}
	if [regexp "^hit" $cmd] {
		if {$BSOP != $FROM} {return}
		BS_Outgoing 1
		::Sound::event BSHIT
	}
	if [regexp "^miss" $cmd] {
		if {$BSOP != $FROM} {return}
		BS_Outgoing 0
	}
	if [regexp "^shot" $cmd] {
		global FROM
		global BSOP
		if {$FROM != $BSOP} {return}
		regsub "^shot " $cmd {} cmd
		regsub ".* " $cmd {} y
		regsub " .*" $cmd {} x
		BS_Incoming $x $y
		return
	}
	if [regexp "^wannaplay" $cmd] {
		global CP
		global BSTURN
		if {($CP == 1) || ($BSTURN != -1)} {return}
		global tprime
		global FROM
		puts $tprime "c15 c$FROM BATTLESHIP.willplay"
		return
	}
	if [regexp "^willplay" $cmd] {
		global FROM
		catch {.bsp.listing.list insert end $FROM}
		return
	}
	if [regexp "^challenge" $cmd] {
		ChalWin Battleship BAccept BDeny
		return
	}
	if [regexp "^deny" $cmd] {
		global FROM
		wintalk .twid.text "$FROM declined your Battleship challenge.\n" {}
		return
	}
	if [regexp "^gameon" $cmd] {
		global FROM
		global BSOP
		global BCHAL
		if {$BSOP != -1} {return}
		if {$FROM != $BCHAL} {return}
		set BCHAL {}
		set BSOP $FROM
		Battleship_Init 2
		return
	}
	if [regexp "^sink" $cmd] {
		global BSOP
		global FROM
		if {$FROM != $BSOP} {return}
		catch {.bsw.mess config -text "That's a sink!"}
	}
	if [regexp "^yield" $cmd] {
		global BSTURN
		global BSOP
		global FROM
		if {$FROM != $BSOP} {return}
		if {$BSTURN == -1} {return}
		catch {.bsw.mess config -text "$BSOP resigns!"}
		SpoolShips
		set BSOP -1
		set BSTURN -1
		tk_dialog .error "$FROM resigns" "$FROM has resigned." error 0 "I Win!"
	}
	if [regexp "^idiot" $cmd] {
		global NAME
		global BSTURN
		global SHOT
		if {$BSOP != $FROM} {return}
		set SHOT(y) -1
		set BSTURN $NAME
		catch {.bsw.mess config -text "Pick again..."}
		return
	}
	if [regexp "^bbox" $cmd] {
		regsub "^bbox *" $cmd {} cmd
		catch {.bsw.top create rectangle [lindex $cmd 0] [lindex $cmd 1] [lindex $cmd 2] [lindex $cmd 3] -fill "" -width 2 -outline $::COLOURS(BSOUTL)}
	} 
}
proc MakeShips {} {
	set HBATTLE {#define hbattle_width 80
#define hbattle_height 20
static char hbattle_bits[] = {
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0x7f,0x00,0x00,0x00,
 0x00,0x00,0xe0,0xff,0xff,0xff,0xff,0x07,0x00,0x00,0x00,0x00,0xfc,0xff,0xff,
 0xff,0xff,0x3f,0x00,0x00,0x00,0xc0,0xff,0xff,0xff,0xff,0xff,0xff,0x03,0x00,
 0x00,0xfc,0xff,0xff,0xff,0xff,0xff,0xff,0x3f,0x00,0x80,0xff,0xff,0x1f,0x1f,
 0x3f,0x3e,0xfe,0xff,0x01,0xf8,0x3f,0xfe,0xef,0xee,0xde,0xdd,0xfd,0x8f,0x1f,
 0xfc,0x01,0xfe,0xf7,0xf5,0xed,0xeb,0xfb,0x0f,0x70,0xfc,0x01,0xfe,0xf7,0xf5,
 0xed,0xeb,0xfb,0x0f,0x70,0xf8,0x3f,0xfe,0xf7,0xf5,0xed,0xeb,0xfb,0x8f,0x1f,
 0x80,0xff,0xff,0xef,0xee,0xde,0xdd,0xfd,0xff,0x01,0x00,0xfc,0xff,0x1f,0x1f,
 0x3f,0x3e,0xfe,0x3f,0x00,0x00,0xc0,0xff,0xff,0xff,0xff,0xff,0xff,0x03,0x00,
 0x00,0x00,0xfc,0xff,0xff,0xff,0xff,0x3f,0x00,0x00,0x00,0x00,0xe0,0xff,0xff,
 0xff,0xff,0x07,0x00,0x00,0x00,0x00,0x00,0xfe,0xff,0xff,0x7f,0x00,0x00,0x00,
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 0x00,0x00,0x00,0x00,0x00};}
	set VBATTLE {#define vbattle_width 20
#define vbattle_height 80
static unsigned char vbattle_bits[] = {
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x0f, 0x00,
   0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00, 0x80, 0x1f, 0x00,
   0x80, 0x1f, 0x00, 0x80, 0x19, 0x00, 0xc0, 0x39, 0x00, 0xc0, 0x39, 0x00,
   0xc0, 0x39, 0x00, 0xc0, 0x39, 0x00, 0xe0, 0x70, 0x00, 0xe0, 0x70, 0x00,
   0xe0, 0x70, 0x00, 0xe0, 0x7f, 0x00, 0xf0, 0xff, 0x00, 0xf0, 0xff, 0x00,
   0xf0, 0xff, 0x00, 0xf8, 0xff, 0x01, 0xf8, 0xff, 0x01, 0xf8, 0xff, 0x01,
   0xf8, 0xff, 0x01, 0xfc, 0xff, 0x03, 0xfc, 0xff, 0x03, 0xfc, 0xf8, 0x03,
   0x7c, 0xf7, 0x03, 0xbc, 0xef, 0x03, 0xbc, 0xef, 0x03, 0xbc, 0xef, 0x03,
   0x7c, 0xf7, 0x03, 0xfc, 0xf8, 0x03, 0xfc, 0xff, 0x03, 0xfc, 0xf8, 0x03,
   0x7c, 0xf7, 0x03, 0xbc, 0xef, 0x03, 0xbc, 0xef, 0x03, 0xbc, 0xef, 0x03,
   0x7c, 0xf7, 0x03, 0xfc, 0xf8, 0x03, 0xfc, 0xff, 0x03, 0xfc, 0xff, 0x03,
   0xfc, 0xf8, 0x03, 0x7c, 0xf7, 0x03, 0xbc, 0xef, 0x03, 0xbc, 0xef, 0x03,
   0xbc, 0xef, 0x03, 0x7c, 0xf7, 0x03, 0xfc, 0xf8, 0x03, 0xfc, 0xff, 0x03,
   0xfc, 0xf8, 0x03, 0x7c, 0xf7, 0x03, 0xbc, 0xef, 0x03, 0xb8, 0xef, 0x01,
   0xb8, 0xef, 0x01, 0x78, 0xf7, 0x01, 0xf8, 0xf8, 0x01, 0xf0, 0xff, 0x00,
   0xf0, 0xff, 0x00, 0xf0, 0xff, 0x00, 0xe0, 0x7f, 0x00, 0xe0, 0x7f, 0x00,
   0xe0, 0x7f, 0x00, 0xe0, 0x7f, 0x00, 0xc0, 0x3f, 0x00, 0xc0, 0x3f, 0x00,
   0xc0, 0x30, 0x00, 0xc0, 0x30, 0x00, 0x80, 0x10, 0x00, 0x80, 0x19, 0x00,
   0x80, 0x19, 0x00, 0x00, 0x09, 0x00, 0x00, 0x09, 0x00, 0x00, 0x09, 0x00,
   0x00, 0x0f, 0x00, 0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00};}
	set HCARRIER {#define hcarrier_width 100
#define hcarrier_height 20
static char hcarrier_bits[] = {
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xfe,0xff,
 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x07,0xfe,0xff,0xff,0xff,
 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x07,0xfe,0xff,0xff,0xff,0xff,0xff,
 0xff,0xff,0xff,0xff,0xff,0xff,0x07,0xfe,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
 0xff,0xff,0xff,0xff,0x07,0xfe,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
 0xff,0xff,0x07,0xfe,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
 0x07,0xfe,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x07,0xfe,
 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x07,0xfe,0xff,0xff,
 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x07,0xfe,0xff,0xff,0xff,0xff,
 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x07,0xfe,0xff,0xff,0xff,0xff,0xff,0xff,
 0xff,0xff,0xff,0xff,0xff,0x07,0xfe,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
 0xff,0xff,0xff,0x07,0xfe,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
 0xff,0x07,0xfe,0xff,0xff,0xff,0x3f,0x00,0xfe,0xff,0xff,0xff,0xff,0xff,0x07,
 0xfe,0xff,0xff,0xff,0x1f,0x00,0xfc,0xff,0xff,0xff,0xff,0xff,0x07,0xfe,0xff,
 0xff,0xff,0x3f,0x00,0xfe,0xff,0xff,0xff,0xff,0xff,0x07,0xfe,0xff,0xff,0xff,
 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x07,0xfe,0xff,0xff,0xff,0xff,0xff,
 0xff,0xff,0xff,0xff,0xff,0xff,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 0x00,0x00,0x00,0x00,0x00};}
	set VCARRIER {#define vcarrier_width 20
#define vcarrier_height 100
static unsigned char vcarrier_bits[] = {
   0x00, 0x00, 0x00, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xee, 0xff, 0x07, 0xc6, 0xff, 0x07, 0xc6, 0xff, 0x07,
   0xc6, 0xff, 0x07, 0xc6, 0xff, 0x07, 0xc6, 0xff, 0x07, 0xc6, 0xff, 0x07,
   0xc6, 0xff, 0x07, 0xc6, 0xff, 0x07, 0xc6, 0xff, 0x07, 0xc6, 0xff, 0x07,
   0xc6, 0xff, 0x07, 0xee, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0x00, 0x00, 0x00};}
	set HCRUISE {#define hcruise_width 60
#define hcruise_height 20
static char hcruise_bits[] = {
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 0x00,0x00,0xe0,0xff,0xff,0xff,0x0f,0x00,0x00,0x00,0xf8,0xff,0xff,0xff,0x3f,
 0x00,0x00,0x00,0xfe,0xff,0xff,0xff,0xff,0x00,0x00,0x80,0xff,0xff,0xff,0xff,
 0xff,0x03,0x00,0xe0,0xff,0xff,0xff,0xff,0xff,0x0f,0x00,0xf0,0xff,0xf8,0xf1,
 0xe3,0xff,0x3f,0x00,0xfc,0x7f,0xf7,0xee,0xdd,0xff,0xff,0x00,0xfe,0xbf,0x6f,
 0xdf,0xbe,0xff,0xff,0x03,0xfe,0xbf,0x0f,0x1f,0x3e,0xff,0xff,0x03,0xfc,0xbf,
 0x6f,0xdf,0xbe,0xff,0xff,0x00,0xf0,0x7f,0xf7,0xee,0xdd,0xff,0x3f,0x00,0xe0,
 0xff,0xf8,0xf1,0xe3,0xff,0x0f,0x00,0x80,0xff,0xff,0xff,0xff,0xff,0x03,0x00,
 0x00,0xfe,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0xf8,0xff,0xff,0xff,0x3f,0x00,
 0x00,0x00,0xe0,0xff,0xff,0xff,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};}
	set VCRUISE {#define vcruise_width 20
#define vcruise_height 60
static unsigned char vcruise_bits[] = {
   0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00,
   0x80, 0x1f, 0x00, 0xc0, 0x3f, 0x00, 0xc0, 0x3f, 0x00, 0xe0, 0x7f, 0x00,
   0xe0, 0x7f, 0x00, 0xf0, 0xff, 0x00, 0xf0, 0xff, 0x00, 0xf8, 0xff, 0x01,
   0xf8, 0xff, 0x01, 0xfc, 0xff, 0x03, 0xfc, 0xf8, 0x03, 0x7c, 0xf7, 0x03,
   0xbc, 0xef, 0x03, 0xbc, 0xef, 0x03, 0xbc, 0xef, 0x03, 0x7c, 0xf7, 0x03,
   0xfc, 0xf8, 0x03, 0xfc, 0xfd, 0x03, 0xfc, 0xfd, 0x03, 0xfc, 0xf8, 0x03,
   0x7c, 0xf7, 0x03, 0xbc, 0xef, 0x03, 0xbc, 0xef, 0x03, 0xbc, 0xef, 0x03,
   0x7c, 0xf7, 0x03, 0xfc, 0xf8, 0x03, 0xfc, 0xfd, 0x03, 0xfc, 0xfd, 0x03,
   0xfc, 0xf8, 0x03, 0x7c, 0xf7, 0x03, 0xbc, 0xef, 0x03, 0xbc, 0xef, 0x03,
   0xbc, 0xef, 0x03, 0x7c, 0xf7, 0x03, 0xfc, 0xf8, 0x03, 0xfc, 0xfd, 0x03,
   0xfc, 0xff, 0x03, 0xfc, 0xff, 0x03, 0xfc, 0xff, 0x03, 0xfc, 0xff, 0x03,
   0xf8, 0xff, 0x01, 0xf8, 0xff, 0x01, 0xf0, 0xff, 0x00, 0xf0, 0xff, 0x00,
   0xe0, 0x7f, 0x00, 0xe0, 0x7f, 0x00, 0xc0, 0x3f, 0x00, 0xc0, 0x3f, 0x00,
   0x80, 0x1f, 0x00, 0x80, 0x1f, 0x00, 0x00, 0x0f, 0x00, 0x00, 0x0f, 0x00,
   0x00, 0x06, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};}
	set HDESTROYER {#define hdestroyer_width 40
#define hdestroyer_height 20
static char hdestroyer_bits[] = {
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xf8,0xff,0x7f,0x00,0xc0,0xff,0xff,0x7f,
 0x00,0xfc,0xff,0xff,0x7f,0x80,0xff,0xff,0xff,0x7f,0xe0,0xff,0xff,0xff,0x7f,
 0xf0,0xff,0xff,0xff,0x7f,0xf8,0xff,0xff,0xff,0x7f,0xfc,0xff,0xff,0xff,0x7f,
 0xfe,0xff,0xff,0xff,0x7f,0xfe,0xff,0xff,0xff,0x7f,0xfc,0xff,0xff,0xff,0x7f,
 0xf8,0xff,0xff,0xff,0x7f,0xf0,0xff,0xff,0xff,0x7f,0xe0,0xff,0xff,0xff,0x7f,
 0x80,0xff,0xff,0xff,0x7f,0x00,0xfc,0xff,0xff,0x7f,0x00,0xc0,0xff,0xff,0x7f,
 0x00,0x00,0xf8,0xff,0x7f,0x00,0x00,0x00,0x00,0x00};}
	set VDESTROYER {#define destroyer_width 20
#define destroyer_height 40
static unsigned char destroyer_bits[] = {
   0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x0f, 0x00, 0x80, 0x1f, 0x00,
   0xc0, 0x3f, 0x00, 0xe0, 0x7f, 0x00, 0xe0, 0x7f, 0x00, 0xf0, 0xff, 0x00,
   0xf0, 0xff, 0x00, 0xf0, 0xff, 0x00, 0xf8, 0xff, 0x01, 0xf8, 0xff, 0x01,
   0xf8, 0xff, 0x01, 0xf8, 0xff, 0x01, 0xfc, 0xff, 0x03, 0xfc, 0xff, 0x03,
   0xfc, 0xff, 0x03, 0xfc, 0xff, 0x03, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0x00, 0x00, 0x00};}
	set HSUB {#define hsub_width 60
#define hsub_height 20
static char hsub_bits[] = {
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xf8,0xff,0xff,0xff,0x1f,0x00,
 0x00,0x80,0xff,0xff,0xff,0xff,0xff,0x01,0x00,0xf0,0xff,0xff,0xff,0xff,0xff,
 0x0f,0x00,0xf8,0xff,0xff,0xff,0xff,0xff,0x7f,0x00,0xfc,0xff,0xff,0xff,0xff,
 0xff,0xff,0x01,0xfe,0xff,0xff,0xff,0xff,0xff,0xff,0x03,0xfe,0xff,0xff,0xff,
 0xff,0xff,0xff,0x07,0xfe,0xff,0x03,0xfc,0xff,0xff,0xff,0x07,0xfe,0xff,0x01,
 0xf8,0xff,0xff,0xff,0x07,0xfe,0xff,0x01,0xf8,0xff,0xff,0xff,0x07,0xfe,0xff,
 0x03,0xfc,0xff,0xff,0xff,0x07,0xfe,0xff,0xff,0xff,0xff,0xff,0xff,0x07,0xfe,
 0xff,0xff,0xff,0xff,0xff,0xff,0x03,0xfc,0xff,0xff,0xff,0xff,0xff,0xff,0x01,
 0xf8,0xff,0xff,0xff,0xff,0xff,0x7f,0x00,0xf0,0xff,0xff,0xff,0xff,0xff,0x0f,
 0x00,0x80,0xff,0xff,0xff,0xff,0xff,0x01,0x00,0x00,0xf8,0xff,0xff,0xff,0x1f,
 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};}
	set VSUB {#define vsub_width 20
#define vsub_height 60
static unsigned char vsub_bits[] = {
   0x00, 0x00, 0x00, 0xc0, 0x3f, 0x00, 0xe0, 0x7f, 0x00, 0xf0, 0xff, 0x00,
   0xf8, 0xff, 0x01, 0xf8, 0xff, 0x01, 0xf8, 0xff, 0x01, 0xfc, 0xff, 0x03,
   0xfc, 0xff, 0x03, 0xfc, 0xff, 0x03, 0xfc, 0xff, 0x03, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xf9, 0x07, 0xfe, 0xf0, 0x07, 0xfe, 0xf0, 0x07,
   0xfe, 0xf0, 0x07, 0xfe, 0xf0, 0x07, 0xfe, 0xf0, 0x07, 0xfe, 0xf0, 0x07,
   0xfe, 0xf0, 0x07, 0xfe, 0xf0, 0x07, 0xfe, 0xf9, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07, 0xfe, 0xff, 0x07,
   0xfe, 0xff, 0x07, 0xfc, 0xff, 0x03, 0xfc, 0xff, 0x03, 0xfc, 0xff, 0x03,
   0xfc, 0xff, 0x03, 0xf8, 0xff, 0x01, 0xf8, 0xff, 0x01, 0xf8, 0xff, 0x01,
   0xf0, 0xff, 0x00, 0xf0, 0xff, 0x00, 0xf0, 0xff, 0x00, 0xe0, 0x7f, 0x00,
   0xe0, 0x7f, 0x00, 0xc0, 0x3f, 0x00, 0x80, 0x1f, 0x00, 0x00, 0x00, 0x00};}
	image create bitmap vbattle -data $VBATTLE -foreground $::COLOURS(SHIPCOL)
	image create bitmap hbattle -data $HBATTLE -foreground $::COLOURS(SHIPCOL)
	image create bitmap hcarrier -data $HCARRIER -foreground $::COLOURS(SHIPCOL)
	image create bitmap vcarrier -data $VCARRIER -foreground $::COLOURS(SHIPCOL)
	image create bitmap hcruise -data $HCRUISE -foreground $::COLOURS(SHIPCOL)
	image create bitmap vcruise -data $VCRUISE -foreground $::COLOURS(SHIPCOL)
	image create bitmap hdestroyer -data $HDESTROYER -foreground $::COLOURS(SHIPCOL)
	image create bitmap vdestroyer -data $VDESTROYER -foreground $::COLOURS(SHIPCOL)
	image create bitmap vsub -data $VSUB -foreground $::COLOURS(SHIPCOL)
	image create bitmap hsub -data $HSUB -foreground $::COLOURS(SHIPCOL)
}
proc BattleshipCleanup {} {
	catch {image delete vcarrier hcarrier vbattle hbattle hcruise vcruise hdestroyer vdestroyer vsub hsub}
	catch {unset ::WATER}
	catch {unset ::BBOARD}
	catch {unset ::BBOARD0}
	catch {unset ::BBOARD1}
}
proc Reversi_EndGame {} {
	global REVOPP
	global RBOARD
	global tprime
	if {$REVOPP != -1} {
		set i [tk_dialog .error "Resign" "Do you really wish to resign?" questhead 0 No Yes]
		if {$i == 0} {return}
		puts $tprime "c15 c$REVOPP REVERSI.yield"
		set REVOPP -1
	}
	destroy .reversi
	catch {unset RBOARD}
}
proc RSendChal {} {
	if [catch {set name [.rp.listing.list get [.rp.listing.list curselection]]}] {
		tk_dialog .error "Error" "You need to select a name" error 0 Ooops
		return
	}
	puts $::tprime "c15 c$name REVERSI.challenge"
	set ::RCHAL $name
	destroy .rp
}
proc RListP {} {
	set ::CP 0
	puts $::tprime "c15 call REVERSI.wannaplay"
	MakePlayerListing rp "Reversi Players" RSendChal
}
proc ReversiHandle {cmd} {
	global FROM
	global REVOPP
	global NAME
	regsub "^REVERSI\." $cmd {} cmd
	if [regexp "^move" $cmd] {
		if {($NAME != $FROM) && ($FROM != $REVOPP)} {return}
		global NOOP
		global NAME
		set NOOP 0
		regsub "^move " $cmd {} cmd
		set x [expr $cmd / 10]
		set y [expr $cmd - [expr $x * 10]]
		ReversiMove $x $y
	}
	if [regexp "^wannaplay" $cmd] {
		global CP
		global tprime
		if {$CP == 1} {return}
		if {$REVOPP != -1} {return}
		global FROM
		puts $tprime "c15 c$FROM REVERSI.willplay"
	}
	if [regexp "^willplay" $cmd] {
		catch {.rp.listing.list insert end $FROM}
	}
	if [regexp "challenge" $cmd] {
		ChalWin Reversi RAcc RDeny
		return
	}
	if [regexp "deny" $cmd] {
		global FROM
		wintalk .twid.text "$FROM declined your reversi challenge.\n" {}
	}
	if [regexp "gameon" $cmd] {
		global FROM
		global REVOPP
		global RCHAL
		if {$REVOPP != -1} {return}
		if {$FROM != $RCHAL} {return}
		set RCHAL {}
		set REVOPP $FROM
		Reversi_Init 2
	}
	if [regexp "^noop" $cmd] {
		global NAME
		global tprime
		global RETEAM
		global RTURN
		global ONOOP
		global NOOP
		if {$REVOPP != $FROM} {return}
		set RTURN $NAME
		.reversi.mess config -text "It is your turn."
		set curcol $RETEAM
		set ONOOP 1
		if ![ReversiMovesExist] {
			set NOOP 1
		} {
			set NOOP 0
			set ONOOP 0
		}
		if {$NOOP == 1} {
			puts $tprime "c15 c$REVOPP REVERSI.noop"
			Reversi_TallyScore
		}
	}	
	if [regexp "^yield" $cmd] {
		global REVOPP
		global RTURN
		if {$FROM != $REVOPP} {return}
		set REVOPP -1
		set RTURN -1
		.reversi.mess config -text "$FROM resigned!"
	}
}
proc RAcc {who} {
	set ::REVOPP $who
	puts $::tprime "c15 c$who REVERSI.gameon"
	Reversi_Init 1
	destroy .rchal
}
proc RDeny {who} {
	puts $::tprime "c15 c$who REVERSI.deny"
	destroy .rchal
}
proc Reversi_TallyScore {} {
	global RBOARD
	global REVOPP
	global ONOOP
	global NOOP
	global RTEAM
	global RETEAM
	global RTURN
	set myscore 0
	set oscore 0
	if {$REVOPP == -1} {return}
	for {set x 0} {$x < 8} {incr x} {
		for {set y 0} {$y < 8} {incr y} {
			if {[.reversi.board itemcget $RBOARD($x,$y) -fill] == $RTEAM} {
				incr myscore
			}
			if {[.reversi.board itemcget $RBOARD($x,$y) -fill] == $RETEAM} {
				incr oscore
			}
		}
	}
	.reversi.score.label config -text "You: $myscore     $REVOPP: $oscore"
	if {([expr $myscore + $oscore] == 64) || ($myscore == 0) || ($oscore == 0) || (($NOOP == 1) && ($ONOOP == 1))} {
		if {$myscore > $oscore} {
			set mess "You win."
		}
		if {$myscore < $oscore} {
			set mess "You lose."
		}
		if {$myscore == $oscore} {
			set mess "Its a draw."
		}
		.reversi.mess config -text "$mess"
		set REVOPP -1
		set RTURN -1
	} 
}
proc ReversiMovesExist {} {
	global RBOARD
	global RTEAM
	global RETEAM
	global REVOPP
	if {$REVOPP == -1} {return 0}
	for {set x 0} {$x < 8} {incr x} {
		for {set y 0} {$y < 8} {incr y} {
			if {[BoardGet $x $y] != $RTEAM} {continue}
			for {set z -1} {$z < 2} {incr z} {
				for {set zz -1} {$zz < 2} {incr zz} {
					set tempx [expr $x + $z]
					set tempy [expr $y + $zz]
					for {set its 0} {[BoardGet $tempx $tempy] != $RTEAM} {incr its} {
						if {[string length [BoardGet $tempx $tempy]] == 0} {break}
						if {[BoardGet $tempx $tempy] == $::COLOURS(RBACK)} {
							if {$its == 0} {break}
							return 1
						}
						set tempx [expr $tempx + $z]
						set tempy [expr $tempy + $zz]
					}
				}
			}
		}
	}
	return 0
}
proc BoardGet {x y} {
	if [catch {.reversi.board itemcget $::RBOARD($x,$y) -fill} data] {set data ""}
	return $data
}
proc ReversiMove {x y} {
	global REVOPP
	global RTURN
	global NAME
	global FROM
	global RETEAM
	global RTEAM
	global RBOARD
	if {$FROM != $RTURN} {return}
	if {$REVOPP == -1} {return}
	set test 0
	for {set z -1} {$z < 2} {incr z} {
		for {set zz -1} {$zz < 2} {incr zz} {
			if [RTraceLine $x $y $z $zz 0] {
				set test 1
			}
		}
	}
	if {$test == 1} {
		for {set z -1} {$z < 2} {incr z} {
        	        for {set zz -1} {$zz < 2} {incr zz} {
                	        if [RTraceLine $x $y $z $zz 1] {
                        	        set test 1
                	        }
           	     }
	        }
	}
	if {$test == 1} {
		if {$REVOPP == -1} {return}
		if {$RTURN == $NAME} {
			set RTURN $REVOPP
			.reversi.mess config -text "Waiting for $REVOPP to move."
			set curcol $RTEAM
			.reversi.board itemconfig $RBOARD($x,$y) -fill $curcol
		} {
			::Sound::event RVMOVE
			set RTURN $NAME
			.reversi.mess config -text "It is your turn. (Last move: [expr $x + 1] [expr $y + 1])"
			set curcol $RETEAM
			.reversi.board itemconfig $RBOARD($x,$y) -fill $curcol
			if ![ReversiMovesExist] {
				global NOOP
				set NOOP 1
				.reversi.mess config -text "No moves possible, passing."
				set RTURN $REVOPP
				set curcol $RETEAM
				global tprime
				puts $tprime "c15 c$REVOPP REVERSI.noop"
			}
		}
	}
	Reversi_TallyScore
}
proc RTraceLine {x y xo yo z} {
	global RBOARD
	if {$::RTURN == $::NAME} {
		set curcol $::RTEAM
	} {
		set curcol $::RETEAM
	}
	set tempx [expr $x + $xo]
	set tempy [expr $y + $yo]
	if {($tempx > 7) || ($tempx < 0)} {return 0}
	if {($tempy > 7) || ($tempy < 0)} {return 0}
	if {[.reversi.board itemcget $RBOARD($tempx,$tempy) -fill] == $::COLOURS(RBACK)} {return 0}
	if {[.reversi.board itemcget $RBOARD($tempx,$tempy) -fill] == $curcol} {
		if {$z == 0} {
			return 0
		} {
			return 1
		}
	}
	set test [RTraceLine $tempx $tempy $xo $yo 1]
	if {$test >= 1} {
		if {$z == 0} {
			return $test
		} {
			.reversi.board itemconfig $RBOARD($tempx,$tempy) -fill $curcol
			return [expr $tempy + [expr $tempx * 10]]
		}
	} {
		return 0
	}
}
proc LocalReversiMove {x y} {
	global RBOARD
	global NAME
	global RTURN
	if {$RTURN != $NAME} {return}
	set x [Trans $x]
	set y [Trans $y]
	if {($x > 7) || ($x < 0) || ($y > 7) || ($y < 0)} {return}
	if {[.reversi.board itemcget $RBOARD($x,$y) -fill] != $::COLOURS(RBACK)} {
		.reversi.mess config -text "That space is taken."
		return
	}
	set test 0
	for {set z -1} {$z < 2} {incr z} {
		for {set zz -1} {$zz < 2} {incr zz} {
			if [RTraceLine $x $y $z $zz 0] {
				set test 1
			}
		}
	}
	if {$test == 1} {
		.reversi.mess config -text "Moving..."
		global tprime
		global NAME
		global REVOPP
		puts $tprime "c15 c$NAME,$REVOPP REVERSI.move [expr $y + [expr $x * 10]]"
	}
}
proc Reversi_Init {a} {
	global REVOPP
	global RTURN
	global FROM
	global NAME
	global RBOARD
	global RTEAM
	global RETEAM
	global NOOP
	global ONOOP
	array set RBOAR {}
	set NOOP 0
	set ONOOP 0
	if {$a == 1} {
		set RTEAM $::COLOURS(RBLUE)
		set RETEAM $::COLOURS(RRED)
		set RTURN $NAME
	} {
		set RTURN $FROM
		set RTEAM $::COLOURS(RRED)
		set RETEAM $::COLOURS(RBLUE)
	}
	destroy .reversi
	toplevel .reversi
	wm geometry .reversi +30+0
	wm title .reversi Reversi
	canvas .reversi.board -width 344 -height 344
	for {set x 0} {$x < 8} {incr x} {
		for {set y 0} {$y < 8} {incr y} {
			.reversi.board create rect [expr 43 * $x] [expr 43 * $y] [expr 43 + [expr 43 * $x]] [expr 43 + [expr 43 * $y]] -fill $::COLOURS(RBACK) -width 1 -outline $::COLOURS(RLINES)
		}
	}
	set off 5
	for {set y 0} {$y < 8} {incr y} {
		for {set x 0} {$x < 8} {incr x} {
			set RBOARD($x,$y) [.reversi.board create oval [expr $off + [expr 43 * $x]] [expr $off + [expr 43 * $y]] [expr 38 + [expr 43 * $x]] [expr 38 + [expr 43 * $y]] -fill $::COLOURS(RBACK) -width 0 -outline $::COLOURS(RBACK) -tags spot]
		}
	}
	.reversi.board itemconfig $RBOARD(3,3) -fill $::COLOURS(RRED)
	.reversi.board itemconfig $RBOARD(4,3) -fill $::COLOURS(RBLUE)
	.reversi.board itemconfig $RBOARD(4,4) -fill $::COLOURS(RRED)
	.reversi.board itemconfig $RBOARD(3,4) -fill $::COLOURS(RBLUE)
	pack .reversi.board -side top -fill none
	bind .reversi.board <ButtonRelease> {LocalReversiMove %x %y}
	frame .reversi.score
	label .reversi.score.label -text "You: 0     $REVOPP: 0" -anchor w
	pack .reversi.score -side top -fill x -expand true
	pack .reversi.score.label -side left -fill x -expand true
	label .reversi.score.yc -text "Your colour:"
	label .reversi.score.colour -text "  " -background $RTEAM
	pack .reversi.score.yc -side left
	pack .reversi.score.colour -side left
	label .reversi.mess -text Reversi -anchor w
	pack .reversi.mess -side top -fill x
	if {$a == 1} {
		.reversi.mess config -text "Your move."
	} {
		.reversi.mess config -text "$REVOPP gets the first move."
	}
	MakeRelay .reversi
	bind .reversi <Escape> {break}
	wm protocol .reversi WM_DELETE_WINDOW {Reversi_EndGame}
	wm resizable .reversi 0 0
	bind .reversi <Key-F1> {faq REVERH}
}




proc GetKing {} {
	global PCS
	if {$::Mteam == 1} {set king 4} {set king 28}
	for {set y 0} {$y < 8} {incr y} {
		for {set x 0} {$x < 8} {incr x} {
			if {$PCS($y,$x) == $king} {
				return "$x $y"
			}
		}
	}
	return "-1 -1"
}
proc ChessCleanup {} {
	set q 1
	global TURN
	global CHESSOP
	global tprime
	global PCS
	global BOARD
	global team
	if {$TURN != -1} {
		set q [tk_dialog .error "Really Close Chess?" "The game is not done, do\nyou really wish to resign?" questhead 0 No Yes]
	}
	if {$q == 0} {return}
	if {($TURN != -1) && ($q == 1)} {
		puts $tprime "c15 c$CHESSOP CHESS.yield"
	}
	set TURN -1
	set CHESSOP -1
	catch {unset team}
	catch {unset BOARD}
	catch {unset PCS}
	catch {image delete wknight}
	catch {image delete bknight}
	catch {image delete wrook}
	catch {image delete brook}
	catch {image delete wbishop}
	catch {image delete bbishop}
	catch {image delete wqueen}
	catch {image delete bqueen}
	catch {image delete wking}
	catch {image delete bking}
	catch {image delete bpawn}
	catch {image delete wpawn}
	destroy .chess
}
proc ChessAcc {who} {
	set ::CHESSOP $who
	puts $::tprime "c15 c$who CHESS.gameon"
	set ::TURN $::NAME
	Chess_InitBoard 1
	.chess.mess config -text "Your move, you are White (north)."
	destroy .cchal
}
proc ChessDeny {who} {
	puts $::tprime "c15 c$who CHESS.denied"
	destroy .cchal
}
proc ChessSendChal {} {
	if {$::TURN != -1} {return}
	if [catch {set name [.clist.listing.list get [.clist.listing.list curselection]]}] {
		tk_dialog .error "Error" "You need to select a name" error 0 Oops
		return
	}
	set ::CCHAL $name
	puts $::tprime "c15 c$name CHESS.challenge"
	destroy .clist
}
proc ChessFindPlayers {} {
	set ::CP 0
	MakePlayerListing clist "Chess Players" ChessSendChal
	puts $::tprime "c15 call CHESS.wannaplay3"
}
proc ChessHandle {cmd} {
	global FROM
	global NAME
	global CHESSOP
	regsub "^CHESS\." $cmd {} cmd
	if [regexp "^yield" $cmd] {
		global TURN
		if {$FROM == $CHESSOP} {
			.chess.mess config -text "$CHESSOP resigns!"
			set TURN -1
			set CHESSOP ""
		}
		if {$FROM == $NAME} {
			catch {.chess.mess config -text "You resign."}
			set TURN -1
			set CHESSOP ""
		}
		return
	}
	if [regexp "^move_selection" $cmd] {
		if {($FROM != $CHESSOP) && ($FROM != $NAME)} {return}
		regsub "^move_selection " $cmd {} cmd
		regsub ". " $cmd {} y
		regsub " ." $cmd {} x
		catch {ChessMove $x $y}
		return
	}
	if [regexp "^select" $cmd] {
		if {$FROM != $CHESSOP} {return}
		regsub "^select " $cmd {} cmd
		regsub ". " $cmd {} y
		regsub " ." $cmd {} x
		catch {RemoteSelectPiece $x $y}
		return
	}
	if [regexp "^wannaplay3" $cmd] {
		global CP
		if {$CP == 1} {return}
		if {$CHESSOP != -1} {return}
		global tprime
		global FROM
		puts $tprime "c15 c$FROM CHESS.willingtoplay2"
		return
	}
	if [regexp "^willingtoplay2" $cmd] {
		global FROM
		catch {.clist.listing.list insert end $FROM}
		return
	}
	if [regexp "^challenge" $cmd] {
		ChalWin Chess ChessAcc ChessDeny
		return
	}
	if [regexp "^denied" $cmd] {
		global FROM
		wintalk .twid.text "$FROM declined your chess challenge.\n" {}
		return
	}
	if [regexp "^gameon" $cmd] {
		global CHESSOP
		global FROM
		global TURN
		global CCHAL
		if {$CHESSOP != -1} {return}
		if {$FROM != $CCHAL} {return}
		set CCHAL {}
		set CHESSOP $FROM
		set TURN $CHESSOP
		Chess_InitBoard 2
		.chess.mess config -text "$CHESSOP's move. You are Black (south)."
		return
	}
}
proc EPhandler {cmd} {
	global HANDLERS
	global CP
	if [regexp "^c" $cmd] {
		global FROM
		regsub "^c" $cmd {} cmd
		regsub " .*" $cmd {} FROM
		regsub "\[^ \]* " $cmd {} cmd
		regsub -all "\n" $cmd {} cmd
		if [regexp "^CHESS" $cmd] {
			ChessHandle $cmd
		}
		if [regexp "^DRAW" $cmd] {
			catch {DrawHandle $cmd}
		}
		if [regexp "^C4" $cmd] {
			wintalk .twid.text "$FROM declined your Connect 4 challenge.\n" {}
		}
		if [regexp "^REVERSI" $cmd] {
			ReversiHandle $cmd
		}
		if [regexp "^BATTLESHIP" $cmd] {
			BattleHandle $cmd
		}
		if [regexp "^DEBUG" $cmd] {
			DebugHandle $cmd
		}
		foreach of [array names HANDLERS] {
			if [regexp "^$of" $cmd] {
				$HANDLERS($of) $cmd
				return
			}
		}
		return
	}
	if [regexp "^h" $cmd] {
		global CMD_ID
		regsub \n $cmd {} cmd
		regsub "^h" $cmd {} temp
		if {$temp == {}} {
			Capture::process {}
			catch {unset ::CAPTURES($CMD_ID)}
			set CMD_ID {}
			return 1
		}
		set CMD_ID $temp
		return 1
	}
	if [regexp "^d" $cmd] {
		global NAME
		regsub -all "\n" $cmd {} cmd
		regsub "^d" $cmd {} NAME
		wm title . "TkTurf - $NAME"
		return
	}
	if [regexp "^e" $cmd] {
		global IP
		if [string length $IP] {return}
		regsub "^e" $cmd {} IP
		regsub -all "\n" $IP {} IP
		return
	}
}
proc ListSetScroll {scrollbar geoCmd offset size} {
	if {$offset != 0.0 || $size != 1.0} {
		eval $geoCmd
		$scrollbar set $offset $size
	} else {
		set manager [lindex $geoCmd 0]
		$manager forget $scrollbar
	}
}
proc ScrolledListWidget { frame args } {
	frame $frame
	listbox $frame.list \
		-xscrollcommand [list ListSetScroll $frame.xscroll [list grid $frame.xscroll -row 1 -column 0 -sticky we]] \
		-yscrollcommand [list ListSetScroll $frame.yscroll [list grid $frame.yscroll -row 0 -column 1 -sticky ns]]
	eval {$frame.list configure} $args
	scrollbar $frame.xscroll -orient horizontal -command "$frame.list xview" -width $::PREFS(SWIDTH)
	scrollbar $frame.yscroll -orient vertical -command "$frame.list yview" -width $::PREFS(SWIDTH)
	grid $frame.list $frame.yscroll -sticky news
	grid $frame.xscroll -sticky news
	grid rowconfigure $frame 0 -weight 1
	grid columnconfigure $frame 0 -weight 1
	return $frame.list
}
proc Chess_numtoname {num} {
	if {$num >= 9 && $num <= 24} {return pawn}
	if {$num == 1 || $num == 8 || $num == 25 || $num == 32} {return rook}
	if {$num == 2 || $num == 7 || $num == 26 || $num == 31} {return knight}
	if {$num == 3 || $num == 6 || $num == 27 || $num == 30} {return bishop}
	if {$num == 5 || $num == 29} {return queen}
	return king
}
proc IsCheckMate {} {
	global PCS
	global PSEL
	global Mteam
	global team
	set oldpsel(x) $PSEL(x)
	set oldpsel(y) $PSEL(y)
	if {$Mteam == 1} {
		set max 16
		set min 1
		set emax 32
		set emin 17
	} {
		set max 32
		set min 17
		set emax 16
		set emin 1
	}
	for {set y 0} {$y < 8} {incr y} {
	for {set x 0} {$x < 8} {incr x} {
	if {($PCS($y,$x) <= $max) && ($PCS($y,$x) >= $min)} {
	for {set sy 0} {$sy < 8} {incr sy} {
	for {set sx 0} {$sx < 8} {incr sx} {
	if {(($PCS($sy,$sx) >= $emin) && ($PCS($sy,$sx) <= $emax)) || ($PCS($sy,$sx) == 0)} {
		set PSEL(x) $x
		set PSEL(y) $y
		if {[IsLegal $sx $sy 0] == 1} {
			set oldpiece $PCS($sy,$sx)
			set PCS($sy,$sx) $PCS($y,$x)
			set PCS($y,$x) 0
			regexp "(.) (.)" [GetKing] junk kx ky
			if ![IsSpaceUnderAttack $Mteam $kx $ky] {
				set PCS($y,$x) $PCS($sy,$sx)
				set PCS($sy,$sx) $oldpiece
				if {($PCS($y,$x) == 4) || ($PCS($y,$x) == 28)} {
					if [IsSpaceUnderAttack $Mteam $kx $ky] {
						break
					}
				}
				set PSEL(x) $oldpsel(x)
				set PSEL(y) $oldpsel(y)
				return 0
			}
			set PCS($y,$x) $PCS($sy,$sx)
			set PCS($sy,$sx) $oldpiece
		}
	}
	}
	}
	}
	}
	}
	set PSEL(x) $oldpsel(x)
	set PSEL(y) $oldpsel(y)
	return 1
}
proc ChessMove {x y} {
	global BOARD
	global PSEL
	global team
	global PCS
	global CFCOL
	global TURN
	global FROM
	global CHESSOP
	global NAME
	global Mteam
	global tprime
	if {$FROM != $TURN} {return}
	if {($PSEL(x) == -1) || ($PSEL(y) == -1)} {return}
	if {[IsLegal $x $y 1] != 1} {return}
	if {$FROM != $NAME} {::Sound::event CHMOVE}
	wintalk .chess.log.text "\n$TURN: [expr $PSEL(x) +1],[expr $PSEL(y) + 1] to [expr $x + 1],[expr $y + 1]" {}
	if {$PCS($y,$x) != 0} {
		wintalk .chess.log.text " \(killed: [Chess_numtoname $PCS($y,$x)]\)" {}
	}
	catch {.chess.board itemconfig $BOARD($PSEL(y),$PSEL(x)) -fill $CFCOL}
	if {$PCS($y,$x)} {
		if {$PCS($y,$x) == 28} {
			if [regexp "mine" [.chess.board gettags $team($PCS($y,$x))]] {
				.chess.mess config -text "You lost."
			} {
				.chess.mess config -text "You win!"
			}
			set TURN -1
		}
		if {$PCS($y,$x) == 4} {
			if [regexp "mine" [.chess.board gettags $team($PCS($y,$x))]] {
				.chess.mess config -text "You lost."
			} {
				.chess.mess config -text "You win!"
			}
			set TURN -1
		}
		.chess.board delete $team($PCS($y,$x))
	} {
		if {$PCS($PSEL(y),$PSEL(x)) >= 17 && $y == 2 && ($PCS(3,$x) >= 9 && $PCS(3,$x) <= 16)} {
			if [regexp "enpassant" [.chess.board gettags $team($PCS(3,$x))]] {
				.chess.board delete $team($PCS(3,$x))
				set PCS(3,$x) 0
				wintalk .chess.log.text " \(killed: pawn\)" {}
			}
		}
		if {$PCS($PSEL(y),$PSEL(x)) <= 16  && $y == 4 && ($PCS(4,$x) >= 17 && $PCS(4,$x) <= 24)} {
			if [regexp "enpassant" [.chess.board gettags $team($PCS(4,$x))]] {
				.chess.board delete $team($PCS(4,$x))
				set PCS(4,$x) 0
				wintalk .chess.log.text " \(killed: pawn\)" {}
			}
		}
	}
	set PCS($y,$x) $PCS($PSEL(y),$PSEL(x))
	set PCS($PSEL(y),$PSEL(x)) 0
	set tx [expr 43 * [expr $x - $PSEL(x)]]
	set ty [expr 43 * [expr $y - $PSEL(y)]]
	.chess.board move $team($PCS($y,$x)) [expr 43 * [expr $x - $PSEL(x)]] [expr 43 * [expr $y - $PSEL(y)]]
	if {(($PCS($y,$x) >= 9) && ($PCS($y,$x) <= 16)) && ($y == 7)} {
		.chess.board itemconfig $team($PCS($y,$x)) -image wqueen
	}
	if {(($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 24)) && ($y == 0)} {
		.chess.board itemconfig $team($PCS($y,$x)) -image bqueen
	} 
	set PSEL(x) -1
	set PSEL(y) -1
	set nuke 0
	if {$TURN == $NAME} {
		if {$Mteam == 1} {set nuke 2} {set nuke 1}
	} {
		set nuke $Mteam
	}
	if {$nuke == 1} {set nuke {9 10 11 12 13 14 15 16}} {set nuke {17 18 19 20 21 22 23 24}}
	foreach of $nuke {
		.chess.board dtag $team($of) enpassant
	}
	if {$TURN == -1} {return}
	if {$TURN == $NAME} {
		set TURN $CHESSOP
		 .chess.mess config -text "Waiting for $CHESSOP to move."
	} {
		set TURN $NAME
		.chess.mess config -text "It is your turn."
		if {$Mteam == 1} {
			set temp [.chess.board coords $team(4)]
		} {
			set temp [.chess.board coords $team(28)]
		}
		regsub " .*" $temp {} kx
		regsub ".* " $temp {} ky
		set kx [Trans $kx]
		set ky [Trans $ky]
		if [IsSpaceUnderAttack $Mteam $kx $ky] {
			.chess.mess config -text "Check!"
			if [IsCheckMate] {
				.chess.mess config -text "Checkmate."
				puts $tprime "c15 c$CHESSOP CHESS.yield"
				set TURN -1
			}
		}
	}
}
proc IsSpaceUnderAttack {side x y} {
	global PCS
	global PSEL
	global team
	set underattack 0
	if {$side == 1} {
		set min 17
		set max 33
	} {
		set min 1
		set max 17
	}
	set oldpsel(x) $PSEL(x)
	set oldpsel(y) $PSEL(y)
	set oldpiece $PCS($y,$x)
	if {$side == 1} {
		set PCS($y,$x) 4
	} {set PCS($y,$x) 28}
	for {} {$min < $max} {incr min} {
		set temp [.chess.board coords $team($min)]
		regsub " .*" $temp {} PSEL(x)
		regsub ".* " $temp {} PSEL(y)
		set PSEL(x) [Trans $PSEL(x)]
		set PSEL(y) [Trans $PSEL(y)]
		if {($PSEL(x) == $x) && ($PSEL(y) == $y)} {
			continue
		}
		if {[IsLegal $x $y 0] == 1} {
			set underattack 1
			break
		}
	}
	set PSEL(x) $oldpsel(x)
	set PSEL(y) $oldpsel(y)
	set PCS($y,$x) $oldpiece
	return $underattack
}
proc LocalMove {x y} {
	global tprime
	global PSEL
	global NAME
	global TURN
	global CHESSOP
	global PCS
	global team
	global Mteam
	if {($PSEL(x) == -1) || ($PSEL(y) == -1)} {return}
	if {$TURN != $NAME} {.chess.mess config -text "It is not your turn right now!"; return}
	set x [Trans $x]
	set y [Trans $y]
	set pbx $PSEL(x)
	set pby $PSEL(y)
	set bx $x
	set by $y
	set InitTarg $PCS($by,$bx)
	set InitPiece $PCS($pby,$pbx)
	if {[IsLegal $x $y 0] != 1} {return}
	if {$Mteam == 1} {
		if {$PCS($PSEL(y),$PSEL(x)) != 4} {
			set temp [.chess.board coords $team(4)]
			regsub " .*" $temp {} x
			regsub ".* " $temp {} y
			set x [Trans $x]
			set y [Trans $y]
		}
		set PCS($pby,$pbx) 0
		set PCS($by,$bx) $InitPiece
		for {set t 17} {$t < 33} {incr t} {
			set temp [.chess.board coords $team($t)]
			regsub " .*" $temp {} PSEL(x)
			regsub ".* " $temp {} PSEL(y)
			set PSEL(x) [Trans $PSEL(x)]
			set PSEL(y) [Trans $PSEL(y)]
			if {($PSEL(x) == $bx) && ($PSEL(y) == $by)} {
				continue
			}
			if {[IsLegal $x $y 0] == 1} {
				.chess.mess config -text "You may not place the king in check."
				set PSEL(x) $pbx
				set PSEL(y) $pby
				set PCS($pby,$pbx) $InitPiece
				set PCS($by,$bx) $InitTarg
				return
			}
		}
	} {
		if {$PCS($PSEL(y),$PSEL(x)) != 28} {
			set temp [.chess.board coords $team(28)]
			regsub " .*" $temp {} x
			regsub ".* " $temp {} y
			set x [Trans $x]
			set y [Trans $y]
		}
		set PCS($pby,$pbx) 0
		set PCS($by,$bx) $InitPiece
		for {set t 1} {$t < 17} {incr t} {
			set temp [.chess.board coords $team($t)]
			regsub " .*" $temp {} PSEL(x)
			regsub ".* " $temp {} PSEL(y)
			set PSEL(x) [Trans $PSEL(x)]
			set PSEL(y) [Trans $PSEL(y)]
			if {($PSEL(x) == $bx) && ($PSEL(y) == $by)} {
				continue
			}
			if {[IsLegal $x $y 0] == 1} {
				.chess.mess config -text "You may not place the king in check."
				set PSEL(x) $pbx
				set PSEL(y) $pby
				set PCS($pby,$pbx) $InitPiece
				set PCS($by,$bx) $InitTarg
				return
			}
		}
	}
	set PSEL(x) $pbx
	set PSEL(y) $pby
	set PCS($pby,$pbx) $InitPiece
	set PCS($by,$bx) $InitTarg
	.chess.mess config -text "Moving..."
	puts $tprime "c15 c$NAME,$CHESSOP CHESS.move_selection $bx $by"
}
proc IsLegal {x y tst} {
	global PSEL
	global PCS
	global BOARD
	global CFCOL
	global team
	if {$PSEL(x) == -1} {.chess.mess config -text "You must select a piece first."; return 0}
	if {($PCS($PSEL(y),$PSEL(x)) >= 9) && ($PCS($PSEL(y),$PSEL(x)) <= 16) && ([string compare "wpawn" [.chess.board itemcget $team($PCS($PSEL(y),$PSEL(x))) -image]] == 0)} {
		if {([expr $y - $PSEL(y)] == 1) && ($PCS($y,$x) == 0) && ([expr $x - $PSEL(x)] == 0)} {
			.chess.board dtag $team($PCS($PSEL(y),$PSEL(x))) enpassant
			return 1
		}	
		if {([expr $y - $PSEL(y)] == 1) && ([expr $x - $PSEL(x)] == 1) && (($PCS($y,$x) >= 17) || (($PCS([expr $y -1],$x) >= 17) && ([regexp enpassant [.chess.board gettags $team($PCS([expr $y -1],$x))]])))} {
			if {([regexp enpassant [.chess.board gettags $team($PCS([expr $y -1],$x))]]) && ($tst == 1) && ($PCS([expr $y -1],$x) >= 17)} {
#				.chess.board delete $team($PCS([expr $y - 1],$x))
#				set PCS([expr $y -1],$x) 0
			}
			.chess.board dtag $team($PCS($PSEL(y),$PSEL(x))) enpassant
			return 1
		}
		if {([expr $y - $PSEL(y)] == 1) && ([expr $x - $PSEL(x)] == -1) && (($PCS($y,$x) >= 17) || (($PCS([expr $y -1],$x) >= 17) && ([regexp enpassant [.chess.board gettags $team($PCS([expr $y -1],$x))]])))} {
			if {([regexp enpassant [.chess.board gettags $team($PCS([expr $y -1],$x))]]) && ($tst == 1) && ($PCS([expr $y -1],$x) >= 17)} {
#				.chess.board delete $team($PCS([expr $y - 1],$x))
#				set PCS([expr $y -1],$x) 0
			}
			.chess.board dtag $team($PCS($PSEL(y),$PSEL(x))) enpassant
			return 1
		}
		if {([expr $y - $PSEL(y)] == 2) && ($PSEL(y) == 1) && ([expr $x - $PSEL(x)] == 0) && ($PCS($y,$x) == 0)} {
			.chess.board itemconfig $team($PCS($PSEL(y),$PSEL(x))) -tags "[.chess.board gettags $team($PCS($PSEL(y),$PSEL(x)))] enpassant"
			return 1
		}
	} 
	if {($PCS($PSEL(y),$PSEL(x)) >= 17) && ($PCS($PSEL(y),$PSEL(x)) <= 24) && ([string compare "bpawn" [.chess.board itemcget $team($PCS($PSEL(y),$PSEL(x))) -image]] == 0)} {
		if {([expr $y - $PSEL(y)] == -1) && ($PCS($y,$x) == 0) && ([expr $x - $PSEL(x)] == 0)} {
			.chess.board dtag $team($PCS($PSEL(y),$PSEL(x))) enpassant
			return 1
		}	
		if {([expr $y - $PSEL(y)] == -1) && ([expr $x - $PSEL(x)] == 1) && ((($PCS($y,$x) <= 16) && ($PCS($y,$x) > 0)) || ((($PCS([expr $y +1],$x) <= 16) && ($PCS([expr $y +1],$x) > 0))&& ([regexp enpassant [.chess.board gettags $team($PCS([expr $y +1],$x))]])))} {
			if {([regexp enpassant [.chess.board gettags $team($PCS([expr $y +1],$x))]]) && ($tst == 1) && (($PCS([expr $y +1],$x) <= 16) && ($PCS([expr $y +1],$x) > 0))} {
#				.chess.board delete $team($PCS([expr $y + 1],$x))
#				set PCS([expr $y +1],$x) 0
			}
			.chess.board dtag $team($PCS($PSEL(y),$PSEL(x))) enpassant
			return 1
		}
		if {([expr $y - $PSEL(y)] == -1) && ([expr $x - $PSEL(x)] == -1) && ((($PCS($y,$x) <= 16) && ($PCS($y,$x) > 0)) || ((($PCS([expr $y +1],$x) <= 16) && ($PCS([expr $y +1],$x) > 0))&& ([regexp enpassant [.chess.board gettags $team($PCS([expr $y +1],$x))]])))} {
			if {([regexp enpassant [.chess.board gettags $team($PCS([expr $y +1],$x))]]) && ($tst == 1) && (($PCS([expr $y +1],$x) <= 16) && ($PCS([expr $y +1],$x) > 0))} {
#				.chess.board delete $team($PCS([expr $y + 1],$x))
#				set PCS([expr $y +1],$x) 0
			}
			.chess.board dtag $team($PCS($PSEL(y),$PSEL(x))) enpassant
			return 1
		}
		if {([expr $y - $PSEL(y)] == -2) && ($PSEL(y) == 6) && ([expr $x - $PSEL(x)] == 0) && ($PCS($y,$x) == 0)} {
			.chess.board itemconfig $team($PCS($PSEL(y),$PSEL(x))) -tags "[.chess.board gettags $team($PCS($PSEL(y),$PSEL(x)))] enpassant"
			return 1
		}
	}
	if {($PCS($PSEL(y),$PSEL(x)) == 1) || ($PCS($PSEL(y),$PSEL(x)) == 8)} {
		if {([expr $y - $PSEL(y)]) && ([expr $x - $PSEL(x)] == 0)} {
			if {[expr $y - $PSEL(y)] > 0} {
				for {set s [expr $PSEL(y) + 1]} {$s != $y} {incr s} {
					if {$PCS($s,$x)} {
						return 0
					}
				}
				if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
				if {$tst == 1} {
					.chess.board dtag $team($PCS($PSEL(y),$PSEL(x))) castle
				}
				return 1
			}
			if {[expr $y - $PSEL(y)] < 0} {
				for {set s [expr $PSEL(y) - 1]} {$s != $y} {incr s -1} {
					if {$PCS($s,$x)} {
						return 0
					}
				}
				if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
				if {$tst == 1} {
					.chess.board dtag $team($PCS($PSEL(y),$PSEL(x))) castle
				}
				return 1
			}
		}
		if {([expr $x - $PSEL(x)]) && ([expr $y - $PSEL(y)] == 0)} {
			if {[expr $x - $PSEL(x)] > 0} {
				for {set s [expr $PSEL(x) + 1]} {$s != $x} {incr s} {
					if {$PCS($y,$s)} {
						return 0
					}
				}
				if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
				if {$tst == 1} {
					.chess.board dtag $team($PCS($PSEL(y),$PSEL(x))) castle
				}
				return 1
			}
			if {[expr $x - $PSEL(x)] < 0} {
				for {set s [expr $PSEL(x) - 1]} {$s != $x} {incr s -1} {
					if {$PCS($y,$s)} {
						return 0
					}
				}
				if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
				if {$tst == 1} {
					.chess.board dtag $team($PCS($PSEL(y),$PSEL(x))) castle
				}
				return 1
			}
		}
	}
	if {($PCS($PSEL(y),$PSEL(x)) == 25) || ($PCS($PSEL(y),$PSEL(x)) == 32)} {
		if {([expr $y - $PSEL(y)]) && ([expr $x - $PSEL(x)] == 0)} {
			if {[expr $y - $PSEL(y)] > 0} {
				for {set s [expr $PSEL(y) + 1]} {$s != $y} {incr s} {
					if {$PCS($s,$x)} {
						return 0
					}
				}
				if {$PCS($y,$x) >= 17} {return 0}
				if {$tst == 1} {
					.chess.board dtag $team($PCS($PSEL(y),$PSEL(x))) castle
				}
				return 1
			}
			if {[expr $y - $PSEL(y)] < 0} {
				for {set s [expr $PSEL(y) - 1]} {$s != $y} {incr s -1} {
					if {$PCS($s,$x)} {
						return 0
					}
				}
				if {$PCS($y,$x) >= 17} {return 0}
				if {$tst == 1} {
					.chess.board dtag $team($PCS($PSEL(y),$PSEL(x))) castle
				}
				return 1
			}
		}
		if {([expr $x - $PSEL(x)]) && ([expr $y - $PSEL(y)] == 0)} {
			if {[expr $x - $PSEL(x)] > 0} {
				for {set s [expr $PSEL(x) + 1]} {$s != $x} {incr s} {
					if {$PCS($y,$s)} {
						return 0
					}
				}
				if {$PCS($y,$x) >= 17} {return 0}
				if {$tst == 1} {
					.chess.board dtag $team($PCS($PSEL(y),$PSEL(x))) castle
				}
				return 1
			}
			if {[expr $x - $PSEL(x)] < 0} {
				for {set s [expr $PSEL(x) - 1]} {$s != $x} {incr s -1} {
					if {$PCS($y,$s)} {
						return 0
					}
				}
				if {$PCS($y,$x) >= 17} {return 0}
				if {$tst == 1} {
					.chess.board dtag $team($PCS($PSEL(y),$PSEL(x))) castle
				}
				return 1
			}
		}
	}
	if {($PCS($PSEL(y),$PSEL(x)) == 2) || ($PCS($PSEL(y),$PSEL(x)) == 7)} {
		if {([expr $x - $PSEL(x)] == 1) && ([expr $y - $PSEL(y)] == 2)} {
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {
				return 0
			}
			return 1
		}
		if {([expr $x - $PSEL(x)] == -1) && ([expr $y - $PSEL(y)] == 2)} {
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {
				return 0
			}
			return 1
		}
		if {([expr $x - $PSEL(x)] == -1) && ([expr $y - $PSEL(y)] == -2)} {
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {
				return 0
			}
			return 1
		}
		if {([expr $x - $PSEL(x)] == 1) && ([expr $y - $PSEL(y)] == -2)} {
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {
				return 0
			}
			return 1
		}
		if {([expr $x - $PSEL(x)] == 2) && ([expr $y - $PSEL(y)] == 1)} {
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {
				return 0
			}
			return 1
		}
		if {([expr $x - $PSEL(x)] == -2) && ([expr $y - $PSEL(y)] == -1)} {
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {
				return 0
			}
			return 1
		}
		if {([expr $x - $PSEL(x)] == -2) && ([expr $y - $PSEL(y)] == 1)} {
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {
				return 0
			}
			return 1
		}
		if {([expr $x - $PSEL(x)] == 2) && ([expr $y - $PSEL(y)] == -1)} {
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {
				return 0
			}
			return 1
		}
		return 0
	}
	if {($PCS($PSEL(y),$PSEL(x)) == 26) || ($PCS($PSEL(y),$PSEL(x)) == 31)} {
		if {([expr $x - $PSEL(x)] == 1) && ([expr $y - $PSEL(y)] == 2)} {
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {
				return 0
			}
			return 1
		}
		if {([expr $x - $PSEL(x)] == -1) && ([expr $y - $PSEL(y)] == 2)} {
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {
				return 0
			}
			return 1
		}
		if {([expr $x - $PSEL(x)] == 1) && ([expr $y - $PSEL(y)] == -2)} {
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {
				return 0
			}
			return 1
		}
		if {([expr $x - $PSEL(x)] == -1) && ([expr $y - $PSEL(y)] == -2)} {
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {
				return 0
			}
			return 1
		}
		if {([expr $x - $PSEL(x)] == 2) && ([expr $y - $PSEL(y)] == 1)} {
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {
				return 0
			}
			return 1
		}
		if {([expr $x - $PSEL(x)] == -2) && ([expr $y - $PSEL(y)] == 1)} {
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {
				return 0
			}
			return 1
		}
		if {([expr $x - $PSEL(x)] == 2) && ([expr $y - $PSEL(y)] == -1)} {
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {
				return 0
			}
			return 1
		}
		if {([expr $x - $PSEL(x)] == -2) && ([expr $y - $PSEL(y)] == -1)} {
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {
				return 0
			}
			return 1
		}
		return 0
	}
	if {($PCS($PSEL(y),$PSEL(x)) == 3) || ($PCS($PSEL(y),$PSEL(x)) == 6)} {
		if {([expr $y - $PSEL(y)] != [expr $x - $PSEL(x)]) && ([expr $y -$PSEL(y)] != [expr -1 * [expr $x - $PSEL(x)]])} {return 0}
		if {([expr $y - $PSEL(y)] > 0) && ([expr $x - $PSEL(x)] > 0)} {
			for {set s [expr $PSEL(y) + 1]; set m [expr $PSEL(x) + 1]} {$s != $y} {incr s;incr m} {
				if {$PCS($s,$m)} {
					return 0
				}
			}
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
			return 1
		}
		if {([expr $y - $PSEL(y)] > 0) && ([expr $x - $PSEL(x)] < 0)} {
			for {set s [expr $PSEL(y) + 1]; set m [expr $PSEL(x) - 1]} {$s != $y} {incr s;incr m -1} {
				if {$PCS($s,$m)} {
					return 0
				}
			}
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
			return 1
		}
		if {([expr $y - $PSEL(y)] < 0) && ([expr $x - $PSEL(x)] > 0)} {
			for {set s [expr $PSEL(y) - 1]; set m [expr $PSEL(x) + 1]} {$s != $y} {incr s -1;incr m} {
				if {$PCS($s,$m)} {
					return 0
				}
			}
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
			return 1
		}
		if {([expr $y - $PSEL(y)] < 0) && ([expr $x - $PSEL(x)] < 0)} {
			for {set s [expr $PSEL(y) - 1]; set m [expr $PSEL(x) - 1]} {$s != $y} {incr s -1;incr m -1} {
				if {$PCS($s,$m)} {
					return 0
				}
			}
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
			return 1
		}
		return 0
	}
	if {($PCS($PSEL(y),$PSEL(x)) == 27) || ($PCS($PSEL(y),$PSEL(x)) == 30)} {
		if {([expr $y - $PSEL(y)] != [expr $x - $PSEL(x)]) && ([expr $y -$PSEL(y)] != [expr -1 * [expr $x - $PSEL(x)]])} {return 0}
		if {([expr $y - $PSEL(y)] > 0) && ([expr $x - $PSEL(x)] > 0)} {
			for {set s [expr $PSEL(y) + 1]; set m [expr $PSEL(x) + 1]} {$s != $y} {incr s;incr m} {
				if {$PCS($s,$m)} {
					return 0
				}
			}
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {return 0}
			return 1
		}
		if {([expr $y - $PSEL(y)] > 0) && ([expr $x - $PSEL(x)] < 0)} {
			for {set s [expr $PSEL(y) + 1]; set m [expr $PSEL(x) - 1]} {$s != $y} {incr s;incr m -1} {
				if {$PCS($s,$m)} {
					return 0
				}
			}
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {return 0}
			return 1
		}
		if {([expr $y - $PSEL(y)] < 0) && ([expr $x - $PSEL(x)] > 0)} {
			for {set s [expr $PSEL(y) - 1]; set m [expr $PSEL(x) + 1]} {$s != $y} {incr s -1;incr m} {
				if {$PCS($s,$m)} {
					return 0
				}
			}
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {return 0}
			return 1
		}
		if {([expr $y - $PSEL(y)] < 0) && ([expr $x - $PSEL(x)] < 0)} {
			for {set s [expr $PSEL(y) - 1]; set m [expr $PSEL(x) - 1]} {$s != $y} {incr s -1;incr m -1} {
				if {$PCS($s,$m)} {
					return 0
				}
			}
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {return 0}
			return 1
		}
	}
	if {($PCS($PSEL(y),$PSEL(x)) == 5) || (($PCS($PSEL(y),$PSEL(x)) >= 9) && ($PCS($PSEL(y),$PSEL(x)) <= 16) && ([string compare "wqueen" [.chess.board itemcget $team($PCS($PSEL(y),$PSEL(x))) -image]] == 0))} {
		if {([expr $y - $PSEL(y)]) && ([expr $x - $PSEL(x)] == 0)} {
			if {[expr $y - $PSEL(y)] > 0} {
				for {set s [expr $PSEL(y) + 1]} {$s != $y} {incr s} {
					if {$PCS($s,$x)} {
						return 0
					}
				}
				if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
				return 1
			}
			if {[expr $y - $PSEL(y)] < 0} {
				for {set s [expr $PSEL(y) - 1]} {$s != $y} {incr s -1} {
					if {$PCS($s,$x)} {
						return 0
					}
				}
				if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
				return 1
			}
		}
		if {([expr $x - $PSEL(x)]) && ([expr $y - $PSEL(y)] == 0)} {
			if {[expr $x - $PSEL(x)] > 0} {
				for {set s [expr $PSEL(x) + 1]} {$s != $x} {incr s} {
					if {$PCS($y,$s)} {
						return 0
					}
				}
				if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
				return 1
			}
			if {[expr $x - $PSEL(x)] < 0} {
				for {set s [expr $PSEL(x) - 1]} {$s != $x} {incr s -1} {
					if {$PCS($y,$s)} {
						return 0
					}
				}
				if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
				return 1
			}
		}
		if {([expr $y - $PSEL(y)] != [expr $x - $PSEL(x)]) && ([expr $y -$PSEL(y)] != [expr -1 * [expr $x - $PSEL(x)]])} {return 0}
		if {([expr $y - $PSEL(y)] > 0) && ([expr $x - $PSEL(x)] > 0)} {
			for {set s [expr $PSEL(y) + 1]; set m [expr $PSEL(x) + 1]} {$s != $y} {incr s;incr m} {
				if {$PCS($s,$m)} {
					return 0
				}
			}
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
			return 1
		}
		if {([expr $y - $PSEL(y)] > 0) && ([expr $x - $PSEL(x)] < 0)} {
			for {set s [expr $PSEL(y) + 1]; set m [expr $PSEL(x) - 1]} {$s != $y} {incr s;incr m -1} {
				if {$PCS($s,$m)} {
					return 0
				}
			}
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
			return 1
		}
		if {([expr $y - $PSEL(y)] < 0) && ([expr $x - $PSEL(x)] > 0)} {
			for {set s [expr $PSEL(y) - 1]; set m [expr $PSEL(x) + 1]} {$s != $y} {incr s -1;incr m} {
				if {$PCS($s,$m)} {
					return 0
				}
			}
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
			return 1
		}
		if {([expr $y - $PSEL(y)] < 0) && ([expr $x - $PSEL(x)] < 0)} {
			for {set s [expr $PSEL(y) - 1]; set m [expr $PSEL(x) - 1]} {$s != $y} {incr s -1;incr m -1} {
				if {$PCS($s,$m)} {
					return 0
				}
			}
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
			return 1
		}
	}
	if {($PCS($PSEL(y),$PSEL(x)) == 29) || (($PCS($PSEL(y),$PSEL(x)) >= 17) && ($PCS($PSEL(y),$PSEL(x)) <= 24) && ([string compare "bqueen" [.chess.board itemcget $team($PCS($PSEL(y),$PSEL(x))) -image]] == 0))} {
		if {([expr $y - $PSEL(y)]) && ([expr $x - $PSEL(x)] == 0)} {
			if {[expr $y - $PSEL(y)] > 0} {
				for {set s [expr $PSEL(y) + 1]} {$s != $y} {incr s} {
					if {$PCS($s,$x)} {
						return 0
					}
				}
				if {$PCS($y,$x) >= 17} {return 0}
				return 1
			}
			if {[expr $y - $PSEL(y)] < 0} {
				for {set s [expr $PSEL(y) - 1]} {$s != $y} {incr s -1} {
					if {$PCS($s,$x)} {
						return 0
					}
				}
				if {$PCS($y,$x) >= 17} {return 0}
				return 1
			}
		}
		if {([expr $x - $PSEL(x)]) && ([expr $y - $PSEL(y)] == 0)} {
			if {[expr $x - $PSEL(x)] > 0} {
				for {set s [expr $PSEL(x) + 1]} {$s != $x} {incr s} {
					if {$PCS($y,$s)} {
						return 0
					}
				}
				if {$PCS($y,$x) >= 17} {return 0}
				return 1
			}
			if {[expr $x - $PSEL(x)] < 0} {
				for {set s [expr $PSEL(x) - 1]} {$s != $x} {incr s -1} {
					if {$PCS($y,$s)} {
						return 0
					}
				}
				if {$PCS($y,$x) >= 17} {return 0}
				return 1
			}
		}
		if {([expr $y - $PSEL(y)] != [expr $x - $PSEL(x)]) && ([expr $y -$PSEL(y)] != [expr -1 * [expr $x - $PSEL(x)]])} {return 0}
		if {([expr $y - $PSEL(y)] > 0) && ([expr $x - $PSEL(x)] > 0)} {
			for {set s [expr $PSEL(y) + 1]; set m [expr $PSEL(x) + 1]} {$s != $y} {incr s;incr m} {
				if {$PCS($s,$m)} {
					return 0
				}
			}
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {return 0}
			return 1
		}
		if {([expr $y - $PSEL(y)] > 0) && ([expr $x - $PSEL(x)] < 0)} {
			for {set s [expr $PSEL(y) + 1]; set m [expr $PSEL(x) - 1]} {$s != $y} {incr s;incr m -1} {
				if {$PCS($s,$m)} {
					return 0
				}
			}
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {return 0}
			return 1
		}
		if {([expr $y - $PSEL(y)] < 0) && ([expr $x - $PSEL(x)] > 0)} {
			for {set s [expr $PSEL(y) - 1]; set m [expr $PSEL(x) + 1]} {$s != $y} {incr s -1;incr m} {
				if {$PCS($s,$m)} {
					return 0
				}
			}
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {return 0}
			return 1
		}
		if {([expr $y - $PSEL(y)] < 0) && ([expr $x - $PSEL(x)] < 0)} {
			for {set s [expr $PSEL(y) - 1]; set m [expr $PSEL(x) - 1]} {$s != $y} {incr s -1;incr m -1} {
				if {$PCS($s,$m)} {
					return 0
				}
			}
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {return 0}
			return 1
		}
	}
	if {$PCS($PSEL(y),$PSEL(x)) == 4} {
		if {(([expr $x - $PSEL(x)] == 1) || ([expr $x - $PSEL(x)] == -1)) && ([expr $y - $PSEL(y)] == 0)} {
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
			.chess.board dtag $team(4) castle
			return 1
		}
		if {(([expr $y - $PSEL(y)] == 1) || ([expr $y - $PSEL(y)] == -1)) && ([expr $x - $PSEL(x)] == 0)} {
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
			.chess.board dtag $team(4) castle
			return 1
		}	
		if {(([expr $y - $PSEL(y)] == 1) || ([expr $y - $PSEL(y)] == -1)) && (([expr $x - $PSEL(x)] == -1) || ([expr $x - $PSEL(x)] == 1))} {
			if {($PCS($y,$x) > 0) && ($PCS($y,$x) <= 16)} {return 0}
			.chess.board dtag $team(4) castle
			return 1
		}
		if {($y == 0) && ($x == 1) && ([regexp "castle" [.chess.board gettags $team(4)]])} {
			if [regexp "castle" [.chess.board gettags $team(1)]] {
				if {($PCS(0,1) == 0) && ($PCS(0,2) == 0)} {
					if [IsSpaceUnderAttack 1 1 0] {return 0}
					if [IsSpaceUnderAttack 1 2 0] {return 0}
					if [IsSpaceUnderAttack 1 3 0] {return 0}
					if {$tst == 0} {return 1}
					.chess.board move $team(1) 86 0
					set PCS(0,0) 0
					set PCS(0,2) 1
					.chess.board dtag $team(1) castle
					.chess.board dtag $team(4) castle
					return 1
				}
			}
		}
		if {($y == 0) && ($x == 5) && ([regexp "castle" [.chess.board gettags $team(4)]])} {
			if [regexp "castle" [.chess.board gettags $team(8)]] {
				if {($PCS(0,4) == 0) && ($PCS(0,5) == 0) && ($PCS(0,6) == 0)} {
					if [IsSpaceUnderAttack 1 3 0] {return 0}
					if [IsSpaceUnderAttack 1 4 0] {return 0}
					if [IsSpaceUnderAttack 1 5 0] {return 0}
					if {$tst == 0} {return 1}
					.chess.board move $team(8) -129 0
					set PCS(0,7) 0
					set PCS(0,4) 8
					.chess.board dtag $team(8) castle
					.chess.board dtag $team(4) castle
					return 1
				}
			}
		}
	}
	if {$PCS($PSEL(y),$PSEL(x)) == 28} {
		if {(([expr $x - $PSEL(x)] == 1) || ([expr $x - $PSEL(x)] == -1)) && ([expr $y - $PSEL(y)] == 0)} {
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {return 0}
			.chess.board dtag $team(28) castle
			return 1
		}
		if {(([expr $y - $PSEL(y)] == 1) || ([expr $y - $PSEL(y)] == -1)) && ([expr $x - $PSEL(x)] == 0)} {
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {return 0}
			.chess.board dtag $team(28) castle
			return 1
		}	
		if {(([expr $y - $PSEL(y)] == 1) || ([expr $y - $PSEL(y)] == -1)) && (([expr $x - $PSEL(x)] == -1) || ([expr $x - $PSEL(x)] == 1))} {
			if {($PCS($y,$x) >= 17) && ($PCS($y,$x) <= 32)} {return 0}
			.chess.board dtag $team(28) castle
			return 1
		}
		if {($y == 7) && ($x == 1) && ([regexp "castle" [.chess.board gettags $team(28)]])} {
			if [regexp "castle" [.chess.board gettags $team(25)]] {
				if {($PCS(7,1) == 0) && ($PCS(7,2) == 0)} {
					if [IsSpaceUnderAttack 2 1 7] {return 0}
					if [IsSpaceUnderAttack 2 2 7] {return 0}
					if [IsSpaceUnderAttack 2 3 7] {return 0}
					if {$tst == 0} {return 1}
					.chess.board move $team(25) 86 0
					set PCS(7,0) 0
					set PCS(7,2) 25
					.chess.board dtag $team(25) castle
					.chess.board dtag $team(28) castle
					return 1
				}
			}
		}
		if {($y == 7) && ($x == 5) && ([regexp "castle" [.chess.board gettags $team(28)]])} {
			if [regexp "castle" [.chess.board gettags $team(32)]] {
				if {($PCS(7,4) == 0) && ($PCS(7,5) == 0) && ($PCS(7,6) == 0)} {
					if [IsSpaceUnderAttack 2 3 7] {return 0}
					if [IsSpaceUnderAttack 2 4 7] {return 0}
					if [IsSpaceUnderAttack 2 5 7] {return 0}
					if {$tst == 0} {return 1}
					.chess.board move $team(32) -129 0
					set PCS(7,7) 0
					set PCS(7,4) 32
					.chess.board dtag $team(32) castle
					.chess.board dtag $team(28) castle
					return 1
				}
			}
		}
	}
	return 0
}
proc Trans {n} {
	if {$n <= 42} {return 0}
	if {$n <= 85} {return 1}
	if {$n <= 128} {return 2}
	if {$n <= 171} {return 3}
	if {$n <= 214} {return 4}
	if {$n <= 257} {return 5}
	if {$n <= 300} {return 6}
	if {$n <= 343} {return 7}
	return -1
}
proc RemoteSelectPiece {x y} {
	global PCS
	global PSEL
	global BOARD
	global CFCOL
	if {$PCS($y,$x) == 0} {return}
	catch {.chess.board itemconfig $BOARD($PSEL(y),$PSEL(x)) -fill $CFCOL}
	set PSEL(x) $x
	set PSEL(y) $y
	set CFCOL [.chess.board itemcget $BOARD($y,$x) -fill]
	.chess.board itemconfig $BOARD($y,$x) -fill $::COLOURS(CHESSHL)
}
proc SelectPiece {x y} {
	global CHESSOP
	global tprime
	global PCS
	global PSEL
	global BOARD
	global CFCOL
	global TURN
	global NAME
	if {$TURN != $NAME} {return}
	set x [Trans $x]
	set y [Trans $y]
	if {$PCS($y,$x) == 0} {return}
	puts $tprime "c15 c$CHESSOP CHESS.select $x $y\n"
	catch {.chess.board itemconfig $BOARD($PSEL(y),$PSEL(x)) -fill $CFCOL}
	set PSEL(x) $x
	set PSEL(y) $y
	set CFCOL [.chess.board itemcget $BOARD($y,$x) -fill]
	.chess.board itemconfig $BOARD($y,$x) -fill $::COLOURS(CHESSHL)
}
proc DefinePieces {} {
	set bishop {#define bishop_width 43
#define bishop_height 43
static unsigned char bishop_bits[] = {
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00,
   0x00, 0x00, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00,
   0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00,
   0x00, 0x00, 0xf8, 0x03, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0x00, 0x00,
   0x00, 0x00, 0xfe, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xff, 0x1f, 0x00, 0x00,
   0x00, 0x80, 0xff, 0x3f, 0x00, 0x00, 0x00, 0xc0, 0xbf, 0x7f, 0x00, 0x00,
   0x00, 0xe0, 0xbf, 0xff, 0x00, 0x00, 0x00, 0xe0, 0xbf, 0xff, 0x00, 0x00,
   0x00, 0xf0, 0xbf, 0xff, 0x01, 0x00, 0x00, 0xf0, 0x07, 0xfc, 0x01, 0x00,
   0x00, 0xf0, 0xbf, 0xff, 0x01, 0x00, 0x00, 0xf0, 0xbf, 0xff, 0x01, 0x00,
   0x00, 0xf0, 0xbf, 0xff, 0x01, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x00, 0x00,
   0x00, 0xe0, 0xff, 0xff, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00,
   0x00, 0xc0, 0x07, 0x7c, 0x00, 0x00, 0x00, 0x80, 0xe1, 0x30, 0x00, 0x00,
   0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00,
   0x00, 0xc0, 0x00, 0x40, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x40, 0x00, 0x00,
   0x00, 0xe0, 0xff, 0xff, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x00, 0x00,
   0x00, 0x00, 0xfe, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00,
   0x00, 0x00, 0xf8, 0x03, 0x00, 0x00, 0xc0, 0xff, 0xff, 0xff, 0x7f, 0x00,
   0xe0, 0xff, 0xff, 0xff, 0xff, 0x00, 0xf0, 0xff, 0xbf, 0xff, 0xff, 0x01,
   0xe0, 0xff, 0x0f, 0xfe, 0xff, 0x00, 0x40, 0x00, 0x00, 0x00, 0x40, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00};}
	image create bitmap wbishop -data $bishop -foreground $::COLOURS(CWHITE)
	image create bitmap bbishop -data $bishop -foreground $::COLOURS(CBLACK)
	set knight {#define knight_width 43
#define knight_height 43
static unsigned char knight_bits[] = {
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x30, 0x00, 0x00, 0x00,
   0x00, 0x70, 0x30, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x78, 0x00, 0x00, 0x00,
   0x00, 0xe0, 0x79, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xff, 0x07, 0x00, 0x00,
   0x00, 0xf0, 0xf8, 0x38, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x47, 0x00, 0x00,
   0x00, 0xf8, 0xff, 0xbf, 0x00, 0x00, 0x00, 0x3c, 0xfe, 0x7f, 0x01, 0x00,
   0x00, 0x1c, 0xff, 0xff, 0x02, 0x00, 0x00, 0xcc, 0xff, 0xff, 0x04, 0x00,
   0x00, 0xec, 0xff, 0xff, 0x05, 0x00, 0x00, 0xec, 0xff, 0xff, 0x09, 0x00,
   0x00, 0xfe, 0xff, 0xff, 0x09, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x13, 0x00,
   0x00, 0xff, 0xff, 0xff, 0x13, 0x00, 0x80, 0xff, 0xff, 0xff, 0x37, 0x00,
   0x80, 0xff, 0xff, 0xff, 0x27, 0x00, 0xc0, 0xff, 0xbf, 0xff, 0x27, 0x00,
   0xc0, 0xff, 0x9f, 0xff, 0x2f, 0x00, 0x60, 0xfe, 0x87, 0xff, 0x4f, 0x00,
   0x60, 0xfe, 0xc1, 0xff, 0x4f, 0x00, 0x60, 0xff, 0xc0, 0xff, 0x4f, 0x00,
   0xe0, 0x3f, 0xe0, 0xff, 0x5f, 0x00, 0xc0, 0x1f, 0xe0, 0xff, 0x5f, 0x00,
   0x80, 0x0f, 0xf0, 0xff, 0x5f, 0x00, 0x00, 0x07, 0xf0, 0xff, 0x5f, 0x00,
   0x00, 0x00, 0xf8, 0xff, 0x5f, 0x00, 0x00, 0x00, 0xfc, 0xff, 0x5f, 0x00,
   0x00, 0x00, 0xfe, 0xff, 0x5f, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x5f, 0x00,
   0x00, 0x00, 0xff, 0xff, 0x5f, 0x00, 0x00, 0x80, 0xff, 0xff, 0x5f, 0x00,
   0x00, 0xc0, 0xff, 0xff, 0x5f, 0x00, 0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00,
   0x00, 0xc0, 0xff, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00};}
	image create bitmap wknight -data $knight -foreground $::COLOURS(CWHITE)
	image create bitmap bknight -data $knight -foreground $::COLOURS(CBLACK)
	set king {#define king_width 43
#define king_height 43
static unsigned char king_bits[] = {
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
   0x00, 0x00, 0xf0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x10, 0x01, 0x00, 0x00, 0x00, 0x00, 0xe8, 0x02, 0x00, 0x00,
   0x00, 0x00, 0xe8, 0x02, 0x00, 0x00, 0x00, 0x7e, 0xe8, 0xc2, 0x0f, 0x00,
   0x00, 0x81, 0xe8, 0x22, 0x10, 0x00, 0x80, 0x7e, 0xe9, 0xd2, 0x2f, 0x00,
   0x40, 0xff, 0xee, 0xee, 0x5f, 0x00, 0xa0, 0xff, 0x5d, 0xf7, 0xbf, 0x00,
   0xd0, 0xff, 0x5b, 0xfb, 0x7f, 0x01, 0xd0, 0xff, 0xb7, 0xfd, 0x7f, 0x01,
   0xd0, 0xff, 0xaf, 0xfe, 0x7f, 0x01, 0xd0, 0xff, 0x5f, 0xff, 0x7f, 0x01,
   0xd0, 0xff, 0x5f, 0xff, 0x7f, 0x01, 0xa0, 0xff, 0x5f, 0xff, 0xbf, 0x00,
   0x40, 0xff, 0x5f, 0xff, 0x5f, 0x00, 0x80, 0xfe, 0x01, 0xf0, 0x2f, 0x00,
   0x00, 0x0d, 0xfc, 0x07, 0x16, 0x00, 0x00, 0xe2, 0xff, 0xff, 0x08, 0x00,
   0x00, 0xfc, 0xff, 0xff, 0x07, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, 0x00,
   0x00, 0xfc, 0xff, 0xff, 0x07, 0x00, 0x00, 0x3c, 0x00, 0x80, 0x07, 0x00,
   0x00, 0x0c, 0xff, 0x3f, 0x06, 0x00, 0x00, 0xfc, 0x03, 0xf8, 0x07, 0x00,
   0x00, 0x1c, 0xfc, 0x07, 0x07, 0x00, 0x00, 0xcc, 0xff, 0x7f, 0x06, 0x00,
   0x00, 0xfc, 0xff, 0xff, 0x07, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x01, 0x00,
   0x00, 0x00, 0xfe, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00};}
	image create bitmap wking -data $king -foreground $::COLOURS(CWHITE)
	image create bitmap bking -data $king -foreground $::COLOURS(CBLACK)
	set pawn {#define pawn_width 43
#define pawn_height 43
static unsigned char pawn_bits[] = {
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x01, 0x00, 0x00,
   0x00, 0x00, 0xf8, 0x03, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0x00, 0x00,
   0x00, 0x00, 0xfc, 0x07, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0x00, 0x00,
   0x00, 0x00, 0xfc, 0x07, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x03, 0x00, 0x00,
   0x00, 0x00, 0xfe, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xff, 0x1f, 0x00, 0x00,
   0x00, 0x80, 0xff, 0x3f, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00,
   0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00,
   0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00,
   0x00, 0x80, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0xff, 0x1f, 0x00, 0x00,
   0x00, 0x00, 0xfe, 0x0f, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x07, 0x00, 0x00,
   0x00, 0x00, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x80, 0xff, 0x3f, 0x00, 0x00,
   0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xe0, 0xff, 0xff, 0x00, 0x00,
   0x00, 0xf0, 0xff, 0xff, 0x01, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x01, 0x00,
   0x00, 0xf8, 0xff, 0xff, 0x03, 0x00, 0x00, 0xf8, 0xff, 0xff, 0x03, 0x00,
   0x00, 0xf8, 0xff, 0xff, 0x03, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, 0x00,
   0x00, 0xfc, 0xff, 0xff, 0x07, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, 0x00,
   0x00, 0xfc, 0xff, 0xff, 0x07, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00};}
	image create bitmap wpawn -data $pawn -foreground $::COLOURS(CWHITE)
	image create bitmap bpawn -data $pawn -foreground $::COLOURS(CBLACK)
	set queen {#define queen_width 43
#define queen_height 43
static unsigned char queen_bits[] = {
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00,
   0x00, 0xf0, 0xf0, 0xc1, 0x01, 0x00, 0x00, 0xf8, 0xf1, 0xe1, 0x03, 0x00,
   0x00, 0xf8, 0xf1, 0xe1, 0x03, 0x00, 0x38, 0xf8, 0xe1, 0xe0, 0x83, 0x03,
   0x7c, 0xf0, 0x40, 0xc0, 0xc1, 0x07, 0x7c, 0x60, 0xe0, 0x80, 0xc0, 0x07,
   0x7c, 0x60, 0xe0, 0xc0, 0xc0, 0x07, 0x38, 0xe0, 0xe0, 0xc0, 0x80, 0x03,
   0x60, 0xe0, 0xe0, 0xe0, 0xc0, 0x00, 0x60, 0xe0, 0xe0, 0xe0, 0xc0, 0x00,
   0xe0, 0xe0, 0xe1, 0xe0, 0xe0, 0x00, 0xe0, 0xe0, 0xe1, 0xf0, 0xe0, 0x00,
   0xc0, 0xf1, 0xf1, 0xf1, 0x71, 0x00, 0xc0, 0xf1, 0xf3, 0xf9, 0x71, 0x00,
   0xc0, 0xf3, 0xf3, 0xf9, 0x79, 0x00, 0xc0, 0xf3, 0xf7, 0xfd, 0x39, 0x00,
   0x80, 0xf7, 0xf7, 0xfd, 0x3d, 0x00, 0x80, 0xff, 0xff, 0xff, 0x3f, 0x00,
   0x80, 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1f, 0x00,
   0x00, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1f, 0x00,
   0x00, 0xfe, 0xff, 0xff, 0x0f, 0x00, 0x00, 0xfe, 0x00, 0xc0, 0x0f, 0x00,
   0x00, 0x06, 0xfe, 0x0f, 0x0c, 0x00, 0x00, 0x04, 0xfe, 0x0f, 0x04, 0x00,
   0x00, 0xfc, 0xff, 0xff, 0x07, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, 0x00,
   0x00, 0xfc, 0x00, 0xc0, 0x07, 0x00, 0x00, 0x0c, 0xff, 0x3f, 0x06, 0x00,
   0x00, 0xfc, 0xff, 0xff, 0x07, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x0f, 0x00,
   0x00, 0xfe, 0xff, 0xff, 0x0f, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1f, 0x00,
   0x00, 0xfe, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0xff, 0x3f, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00};}
	image create bitmap wqueen -data $queen -foreground $::COLOURS(CWHITE)
	image create bitmap bqueen -data $queen -foreground $::COLOURS(CBLACK)
	set rook {#define rook_width 43
#define rook_height 43
static unsigned char rook_bits[] = {
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0xfc, 0xf0, 0xc1, 0x07, 0x00, 0x00, 0xfc, 0xf0, 0xc1, 0x07, 0x00,
   0x00, 0xfc, 0xf0, 0xc1, 0x07, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, 0x00,
   0x00, 0xfc, 0xff, 0xff, 0x07, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, 0x00,
   0x00, 0x18, 0x00, 0x00, 0x03, 0x00, 0x00, 0xf0, 0xff, 0xff, 0x01, 0x00,
   0x00, 0xe0, 0xff, 0xff, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x60, 0x00, 0x00,
   0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00,
   0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00,
   0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00,
   0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00,
   0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00,
   0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00,
   0x00, 0xc0, 0xff, 0x7f, 0x00, 0x00, 0x00, 0xe0, 0x00, 0xe0, 0x00, 0x00,
   0x00, 0xf0, 0xff, 0xff, 0x01, 0x00, 0x00, 0xf8, 0xff, 0xff, 0x03, 0x00,
   0x00, 0xfc, 0xff, 0xff, 0x07, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x06, 0x00,
   0x00, 0xfc, 0xff, 0xff, 0x07, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, 0x00,
   0x00, 0x07, 0x00, 0x00, 0x1c, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1f, 0x00,
   0x00, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0xff, 0xff, 0xff, 0x1f, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00};}
	image create bitmap wrook -data $rook -foreground $::COLOURS(CWHITE)
	image create bitmap brook -data $rook -foreground $::COLOURS(CBLACK)
}
proc Chess_InitBoard {myteam} {
	global team
	global PSEL
	global PCS
	global BOARD
	global Mteam
	set Mteam $myteam
	DefinePieces
	set row 0
	set col 0
	destroy .chess
	toplevel .chess
	wm title .chess Chess
	canvas .chess.board -width 344 -height 344
	pack .chess.board
	ScrolledTextWidget .chess.log -width 3 -height 1 -takefocus 0
	.chess.log.text config -state disabled
	if {$::PREFS(CHESSLOG) == 1} {
		pack .chess.log -side top -fill x -expand true
	}
	label .chess.mess -text "Chess" -anchor w
	pack .chess.mess -side top -fill x -expand true
	set x 0
	set colour $::COLOURS(CHECK2)
	set PSEL(x) -1
	set PSEL(y) -1
	for {} {$row != 8} {} {
		for {} {$col != 8} {incr col} {
			if {$colour == $::COLOURS(CHECK1)} {set colour $::COLOURS(CHECK2)} {set colour $::COLOURS(CHECK1)}
			set BOARD($row,$col) [.chess.board create rect [expr $col * 43 + $x] [expr $row * 43] [expr 43 + [expr $col * 43] +$x] [expr 43 + [expr $row * 43]] -fill $colour -width 0 -tags spot]
		}
		set col 0
		incr row
		if {$colour == $::COLOURS(CHECK1)} {set colour $::COLOURS(CHECK2)} {set colour $::COLOURS(CHECK1)}
	}
	set team(0) "Crash test dummy"
	set team(1) [.chess.board create image 0 0 -image wrook -anchor nw]
	set team(2) [.chess.board create image 43 0 -image wknight -anchor nw]
	set team(3) [.chess.board create image 86 0 -image wbishop -anchor nw]
	set team(4) [.chess.board create image 129 0 -image wking -anchor nw]
	set team(5) [.chess.board create image 172 0 -image wqueen -anchor nw]
	set team(6) [.chess.board create image 215 0 -image wbishop -anchor nw]
	set team(7) [.chess.board create image 258 0 -image wknight -anchor nw]
	set team(8) [.chess.board create image 301 0 -image wrook -anchor nw]
	for {set x 9; set y 1} {$x != 17} {incr x; incr y} {
		set team($x) [.chess.board create image [expr [expr $y -1] * 43] 43 -image wpawn -anchor nw]
	}
	set team(25) [.chess.board create image 0 301 -image brook -anchor nw]
	set team(26) [.chess.board create image 43 301 -image bknight -anchor nw]
	set team(27) [.chess.board create image 86 301 -image bbishop -anchor nw]
	set team(28) [.chess.board create image 129 301 -image bking -anchor nw]
	set team(29) [.chess.board create image 172 301 -image bqueen -anchor nw]
	set team(30) [.chess.board create image 215 301 -image bbishop -anchor nw]
	set team(31) [.chess.board create image 258 301 -image bknight -anchor nw]
	set team(32) [.chess.board create image 301 301 -image brook -anchor nw]
	for {set x 17; set y 1} {$x != 25} {incr x; incr y} {
		set team($x) [.chess.board create image [expr [expr $y -1] * 43] 258 -image bpawn -anchor nw]
	}
	if {$myteam == 1} {
		for {set x 1} {$x <= 16} {incr x} {
			.chess.board itemconfig $team($x) -tags mine 
			if {($x == 4) || ($x == 1) || ($x == 8)} {
				.chess.board itemconfig $team($x) -tags "mine castle"
			}
		}
		for {set x 17} {$x <= 32} {incr x} {
				.chess.board itemconfig $team($x) -tags "spot castle"
		}
	} { 
		if {$myteam == 2} {
			for {set x 17} {$x <= 32} {incr x} {
				.chess.board itemconfig $team($x) -tags mine
				if {($x == 25) || ($x == 28) || ($x == 32)} {
					.chess.board itemconfig $team($x) -tags "mine castle"
				}
			}
			for {set x 1} {$x <= 16} {incr x} {
					.chess.board itemconfig $team($x) -tags "spot castle"
			}
		}
	}
	for {set y 0} {$y <= 7} {incr y} {
		for {set x 0} {$x <= 7} {incr x} {
			set PCS($x,$y) 0
		}
	}
	set PCS(0,0) 1
	set PCS(0,1) 2
	set PCS(0,2) 3
	set PCS(0,3) 4
	set PCS(0,4) 5
	set PCS(0,5) 6
	set PCS(0,6) 7
	set PCS(0,7) 8
	set PCS(1,0) 9
	set PCS(1,1) 10
	set PCS(1,2) 11
	set PCS(1,3) 12
	set PCS(1,4) 13
	set PCS(1,5) 14
	set PCS(1,6) 15
	set PCS(1,7) 16
	set PCS(6,0) 17
	set PCS(6,1) 18
	set PCS(6,2) 19
	set PCS(6,3) 20
	set PCS(6,4) 21
	set PCS(6,5) 22
	set PCS(6,6) 23
	set PCS(6,7) 24
	set PCS(7,0) 25
	set PCS(7,1) 26
	set PCS(7,2) 27
	set PCS(7,3) 28
	set PCS(7,4) 29
	set PCS(7,5) 30
	set PCS(7,6) 31
	set PCS(7,7) 32
	.chess.board bind spot <ButtonRelease> {catch {LocalMove %x %y}}
	.chess.board bind mine <ButtonRelease> {catch {SelectPiece %x %y}}
	bind .chess <Destroy> {ChessCleanup; break}
	wm protocol .chess WM_DELETE_WINDOW {ChessCleanup}
	wm resizable .chess 0 0
	MakeRelay .chess
	bind .chess <Escape> {break}
	bind .chess <Key-F1> {faq CHELP}
}
namespace eval Triggers {
proc load {} {
	notify "Loading Triggers"
	catch {source [::File::get triggers]}
}
proc update {} {
	global triggers
	.trig.list.list delete 0 end
	foreach of [array names triggers] {
		if [regexp "^#TkTurf System Trigger\n" $triggers($of)] {continue}
		.trig.list.list insert end $of
	}
}
proc window {} {
	destroy .trig
	toplevel .trig
	wm title .trig "Trigger Control Panel"
	wm geometry .trig +[winfo pointerx .]+[winfo pointery .]
	ScrolledListWidget .trig.list -selectmode single
	frame .trig.bot
	button .trig.bot.new -text "New" -command {::Triggers::addwindow {}}
	button .trig.bot.edit -text "Edit" -command {catch {::Triggers::addwindow [.trig.list.list get [.trig.list.list curselection]]}}
	button .trig.bot.del -text "Delete" -command {catch {::Triggers::delete [.trig.list.list get [.trig.list.list curselection]]}}
	button .trig.bot.can -text "Close" -command {destroy .trig}
	button .trig.bot.help -text Help -command {faq TRI}
	pack .trig.list -side top -fill both -expand true
	pack .trig.bot -side top -fill x -expand true
	pack .trig.bot.new -side left
	pack .trig.bot.edit -side left
	pack .trig.bot.del -side left
	pack .trig.bot.help -side left
	pack .trig.bot.can -side left
	bind .trig.list.list <Double-Button> {::Triggers::addwindow [.trig.list.list get [.trig.list.list curselection]]}
	catch {::Triggers::update}
	bind .trig <Escape> {destroy .trig}
	center .trig
}
proc delete {name} {
	global triggers
	unset triggers($name)
	catch {::Triggers::update}
	::Triggers::save
}
proc save {} {
	if [catch {::File::open triggers w} file] {
		tk_dialog .error Error "Error: could not open [::File::get triggers] for writing." error 0 Damn
		return
	}
	foreach of [array names ::triggers] {
		if [regexp {#TkTurf System Trigger} $::triggers($of)] continue
		puts $file "set {::triggers($of)} {$::triggers($of)}"
	}
	close $file
}
proc add {name effect old} {
	global triggers
	catch {unset triggers($old)}
	set triggers($name) $effect
	catch {::Triggers::update}
	::Triggers::save
}
proc addwindow {trig} {
	global winc
	global triggers
	incr winc
	toplevel .$winc
	wm title .$winc "Add a Trigger"
	label .$winc.help -text "Triggers in TkTurf use regular expressions for searches, if you are\nnot sure what a regular expression is see the help menu item on them." -anchor w
	pack .$winc.help -side top -fill x -expand true
	frame .$winc.mid
	label .$winc.mid.lab -text "Enter the regular expression to find here"
	entry .$winc.mid.ent -width 35
	catch {.$winc.mid.ent insert end $trig}
	bind .$winc.mid.ent <Return> {focus [tk_focusNext %W]}
	pack .$winc.mid -side top -fill x -expand true
	pack .$winc.mid.lab -side left
	pack .$winc.mid.ent -side left -fill x -expand true
	label .$winc.lab -text "Enter the TCL code to execute when triggered." -anchor w
	ScrolledTextWidget .$winc.code -width 40 -height 10 -wrap word
	if [catch {.$winc.code.text insert end $triggers($trig)}] {
		.$winc.code.text insert end "# This is a sample trigger script\n# All it does is make you say \"This is a default text reply to a trigger\"\n# The ::Sound::play \"\" command would play a sound if the file it was given\n# actually existed. Lines starting with # are comments.\n\n"
		.$winc.code.text insert end {send "say This is a default text reply to a trigger"}
		.$winc.code.text insert end \n
		.$winc.code.text insert end {::Sound::play "/the/default/sound/toplay.wav"}
	}
	pack .$winc.lab -side top -fill x -expand true
	pack .$winc.code -side top -fill x -expand true
	frame .$winc.bot
	button .$winc.bot.add -text "Add Trigger" -command "::Triggers::add \[.$winc.mid.ent get\] \[.$winc.code.text get 0.0 end\] {$trig}; destroy .$winc"
	button .$winc.bot.sound -text "Insert Sound" -command "sndinsert .$winc.code.text"
	button .$winc.bot.can -text Cancel -command "destroy .$winc"
	button .$winc.bot.tri -text "Trigger Help" -command {faq TRI}
	button .$winc.bot.help -text "Scripting Help" -command {faq TCODE}
	pack .$winc.bot.help -side right
	pack .$winc.bot.tri -side right
	pack .$winc.bot.can -side right
	pack .$winc.bot.add -side right
	pack .$winc.bot.sound -side right
	pack .$winc.bot -side top -fill x -expand true
	focus .$winc.mid.ent
	bind .$winc <Escape> "destroy .$winc"
	center .$winc
}
}
proc sndinsert {win} {
	set sfile [getOpenFile]
	if {[string length $sfile] < 1} {
		return
	}
	if ![regexp "\.0$" [$win index insert]] {$win insert insert "\n"}
	$win insert insert "::Sound::play \"$sfile\"\n"
}
namespace eval Login {
proc load {} {
	notify "Loading Autologins"
	catch {source [::File::get logins]}
}
proc delete {name} {
	catch {unset ::logins($name)}
	::Login::save
	catch {::Login::update}
}
proc save {} {
	if [catch {::File::open logins w} file] {
		tk_dialog .error Error "Error: unable to open [::File::get logins] for writing." error 0 Damn
		return
	}
	foreach of [array names ::logins] {
		puts $file "set {::logins($of)} {$::logins($of)}"
	}
	close $file
}
proc update {} {
	global logins
	catch {.dlw.list.list delete 0 end}
	set alist [lsort -ascii [array names logins]]
	set length [llength $alist]
	for {set i 0} {$i != $length} {incr i} {
		.dlw.list.list insert end [lindex $alist $i]
	}
}
proc window {} {
	global logins
	destroy .dlw
	toplevel .dlw
	wm title .dlw "Login Control Panel"
	ScrolledListWidget .dlw.list -selectmode single
	::Login::update
	frame .dlw.bot
	button .dlw.bot.new -text New -command {::Login::addwindow {}}
	button .dlw.bot.edit -text Edit -command {catch {::Login::addwindow [.dlw.list.list get [.dlw.list.list curselection]]}}
	button .dlw.bot.can -text Close -command {destroy .dlw}
	bind .dlw.list.list <Double-Button> {catch {::Login::addwindow [.dlw.list.list get [.dlw.list.list curselection]]}}
	button .dlw.bot.del -text Delete -command {catch {::Login::delete [.dlw.list.list get [.dlw.list.list curselection]]}}
	pack .dlw.list -side top -fill both -expand true
	pack .dlw.bot -side top -fill x -expand true
	pack .dlw.bot.can -side right
	pack .dlw.bot.del -side right
	pack .dlw.bot.edit -side right
	pack .dlw.bot.new -side right
	bind .dlw <Escape> {destroy .dlw}
	center .dlw
}
proc login {name} {
	global logins
	global tprime
	catch {puts $tprime "$name\n$logins($name)\n   \n"}
}
proc loginwin {} {
	global logins
	set names [lsort -ascii [array names logins]]
	if {[llength $names] == 0} {return}
	if {$::PREFS(ALL) == 1} {
		if {[llength $names] == 1} {::Login::login [lindex $names 0]; return}
	}
	destroy .names
	toplevel .names
	wm title .names "Autologin Names"
	ScrolledListWidget .names.list -selectmode single
	set length [llength $names]
        for {set i 0} {$i != $length} {incr i} {
                .names.list.list insert end [lindex $names $i]
        }
	frame .names.bot
	button .names.bot.send -text Login -command {catch {::Login::login [.names.list.list get [.names.list.list curselection]]; destroy .names}}
	button .names.bot.can -text Cancel -command {destroy .names}
	pack .names.list -side top -fill both -expand true
	pack .names.bot -side top -fill x -expand true
	pack .names.bot.can -side right
	pack .names.bot.send -side right
	bind .names.list.list <Double-Button> {::Login::login [.names.list.list get [.names.list.list curselection]]; destroy .names}
	center .names
	bind .names <Escape> {destroy .names}
}
proc add {args} {
	global logins
	catch {unset logins($args)}
	set name [.alw.top.ent get]
	set passwd [.alw.mid.ent get]
	if {([string length $name] < 3) || ([string length $passwd] < 1)} {
		tk_dialog .error Error "Invalid name or password. Names must be 3 or more characters,\n and passwords must exist." error 0 "Ooops"
		return
	}
	set logins($name) $passwd
	destroy .alw
	::Login::save
	catch {::Login::update}
}
proc addwindow {logi} {
	global logins
	destroy .alw
	toplevel .alw
	wm title .alw "Add/Alter Preset Login"
	frame .alw.top
	label .alw.top.lab -text "What is the name of the character?" -anchor w
	entry .alw.top.ent
	catch {.alw.top.ent insert insert $logi}
	bind .alw.top.ent <Return> {focus [tk_focusNext %W]}
	pack .alw.top -side top -fill x -expand true
	pack .alw.top.lab -side left -fill x -expand true
	pack .alw.top.ent -side left
	frame .alw.mid
	label .alw.mid.lab -text "What is that character's password?" -anchor w
	entry .alw.mid.ent -show *
	catch {.alw.mid.ent insert insert $logins($logi)}
	bind .alw.mid.ent <Return> "::Login::add $logi"
	pack .alw.mid -side top -fill x -expand true
	pack .alw.mid.lab -side left -fill x -expand true
	pack .alw.mid.ent -side left
	frame .alw.bot
	button .alw.bot.add -text Add -command "::Login::add $logi"
	button .alw.bot.can -text Cancel -command {destroy .alw}
	pack .alw.bot -side top -fill x -expand true
	pack .alw.bot.can -side right
	pack .alw.bot.add -side right
	bind .alw.bot.add <Return> "::Login::add $logi"
	focus .alw.top.ent
	bind .alw.top.ent <Key-space> {break}
	bind .alw.mid.ent <Key-space> {break}
	bind .alw <Escape> {destroy .alw}
	center .alw
}
}
proc NotifyUser {} {
	global TIMES
	global DONOTIFY
	global NAME
	set DONOTIFY 0
	if {$TIMES == 0} {wm title . "New Message"; set TIMES 2}
	if {$TIMES == 1} {wm title . "TkTurf - $NAME"; set TIMES 0}
	if {$TIMES == 7} {wm title . "TkTurf - $NAME"; return}
	if {$TIMES == 2} {set TIMES 1}
	after 250 NotifyUser
}
proc SetDoNotify {event} {
	global DONOTIFY
	global TIMES
	global VIS
	if {($::PREFS(NOTIFY) == 0) || ($VIS != "VisibilityFullyObscured")} {
		set DONOTIFY 0
		set TIMES 7
		return
	}
	if ![regexp "VisibilityFullyObscured" $event] {
		set TIMES 7
		set DONOTIFY 0
	} {set TIMES 0; set DONOTIFY 1}
}
proc ProcCat {pipe} {
	global tprime
	global MULTI
	if [eof $pipe] {
		catch {close $pipe}
		return
	}
	catch {Spool::enqueue "$MULTI[gets $pipe]"}
}
proc CommandHandle {line} {
	catch {.promptline.mainent delete 0 end}
	if [regexp -nocase "^exec" $line] {
		regsub -nocase "^exec *" $line {} line
		catch {open "|$line" r} proc
		catch {fileevent $proc readable "ProcCat $proc"}
		return
	}
	if !$::PREFS(USEALPHA) return
	eval $line
}
namespace eval Find {
set FIND ""
set IND 0.0
set UP 0
set STYLE 0
proc search {} {
	variable FIND
	variable IND
	variable UP
	variable STYLE
	destroy .find
	if {$IND == -0.1 && $UP == "-backward"} {set IND [.twid.text index "end -1 chars"]}
	if {[string length $FIND] == 0} {.twid.text see end; return}
	if [catch {.twid.text search $STYLE $UP -count chars -- $FIND "$IND +1 chars"} IND] {
		if {$UP == "-backward"} {
			set IND [.twid.text index end]
		} { set IND 0.0}
	}
	catch {.twid.text see $IND}
	catch {.twid.text tag remove sel 1.0 end}
	if {$::tcl_platform(platform) == "windows"} {
		catch {.twid.text tag remove find 0.0 end}
		catch {.twid.text tag add find $IND "$IND + $chars chars"}
	}
	catch {.twid.text tag add sel $IND "$IND + $chars chars"}
	if {$UP == "-backward"} {
		set IND [expr $IND - 0.1]
	}
}
proc window {} {
	variable UP
	variable STYLE
	variable IND
	variable FIND
	set FIND {}
	set IND -0.1
	set UP -backward
	set STYLE -nocase
	destroy .find
	toplevel .find
	wm title .find "Find in Text Window"
	label .find.what -text "Enter a string to find" -anchor w
	entry .find.query -textvariable Find::FIND
	pack .find.what -side top -fill x -expand true
	pack .find.query -side top -fill x -expand true
	frame .find.style
	radiobutton .find.style.norm -text "No Case" -variable Find::STYLE -value -nocase
	radiobutton .find.style.case -text "Case Sensitive" -variable Find::STYLE -value -exact
	radiobutton .find.style.regexp -text "Regular Expression" -variable Find::STYLE -value -regexp
	pack .find.style.norm -side left -fill x
	pack .find.style.case -side left -fill x
	pack .find.style.regexp -side left -fill x
	pack .find.style -side top -fill x
	frame .find.dir
	radiobutton .find.dir.ftop -text "From Top" -variable Find::UP -value -forward
	radiobutton .find.dir.fbot -text "From Bottom" -variable Find::UP -value -backward
	pack .find.dir.ftop -side left -fill x
	pack .find.dir.fbot -side left -fill x
	pack .find.dir -side top -fill x
	frame .find.buts
	button .find.buts.find -text "Find" -command {Find::search}
	button .find.buts.can -text "Cancel" -command {destroy .find}
	pack .find.buts.can -side right
	pack .find.buts.find -side right
	pack .find.buts -side top -fill x -expand true
	bind .find.query <Return> Find::search
	focus .find.query
	bind .find <Escape> {destroy .find}
	wm resizable .find 0 0
	center .find
}
}
proc faq {var} {
	global VERSION
	global $var
	destroy .faq
	toplevel .faq
	wm title .faq "Documentation for TkTurf $VERSION"
	ScrolledTextWidget .faq.main -width 85 -wrap word
	.faq.main.text insert end [set $var]
	.faq.main.text config -state disabled
	pack .faq.main -fill both -expand true
	bind .faq <Escape> {destroy .faq}
	bind .faq <Up> {.faq.main.text yview scroll -1 units}
	bind .faq <Down> {.faq.main.text yview scroll 1 units}
	bind .faq <Next> {.faq.main.text yview scroll 1 pages}
	bind .faq <Prior> {.faq.main.text yview scroll -1 pages}
	center .faq
}
namespace eval Alias {
proc load {} {
	notify "Loading Aliases"
	catch {source [::File::get aliases]}
}
proc save {} {
	global tcl_platform
	if [catch {::File::open aliases w} file] {
		tk_dialog .error "Error" "Could not open ~/.tkturf/aliases for writing." error 0 Okay
		return
	}
	foreach of $::Aliases::names {
		if [regexp {#TkTurf System Alias} [info body ::Aliases::$of]] continue
		puts $file "proc ::Aliases::$of {args} {[info body ::Aliases::$of]}"
	}
	close $file
}
proc delete {del} {
	rename ::Aliases::$del {}
	makelist
	post
	save
}
proc isSystem {alias} {
	if [regexp "#TkTurf System Alias" [info body ::Aliases::$alias]] {return 1}
	return 0
}
proc post {} {
	.adw.list.list delete 0 end
	set alist [lsort -ascii $::Aliases::names]
	set length [llength $alist]
	foreach of $alist {
		if [isSystem $of] {continue}
		.adw.list.list insert end $of
	}
}
proc window {} {
	destroy .adw
	toplevel .adw
	wm title .adw "Alias Control Panel"
	ScrolledListWidget .adw.list -selectmode single
	makelist
	post
	frame .adw.bot
	button .adw.bot.new -text New -underline 0 -command {::Alias::edit {}}
	button .adw.bot.add -text Edit -underline 0 -command {catch {::Alias::edit [.adw.list.list get [.adw.list.list curselection]]}}
	button .adw.bot.cop -text Copy -command {catch {::Alias::copy [.adw.list.list get [.adw.list.list curselection]]}}
	button .adw.bot.can -text Close -underline 0 -command {destroy .adw}
	button .adw.bot.fe -text "Delete" -command {catch {::Alias::delete [.adw.list.list get [.adw.list.list curselection]]}}
	pack .adw.list -side top -fill both
	pack .adw.bot.can -side right
	pack .adw.bot.fe -side right
	pack .adw.bot.cop -side right
	pack .adw.bot.add -side right
	pack .adw.bot.new -side right
	pack .adw.bot -side top -fill x -expand true
	focus .adw.list.list
	bind .adw.list.list <Double-Button> {catch {::Alias::edit [.adw.list.list get [.adw.list.list curselection]]}}
	bind .adw <n> {::Alias::edit {}}
	bind .adw <e> {catch {::Alias::edit [.adw.list.list get [.adw.list.list curselection]]}}
	bind .adw <c> {destroy .adw}
	bind .adw <Escape> {destroy .adw}
	center .adw
}
proc makelist {} {
	namespace eval ::Aliases {set names [info procs]}
}
proc copy {name} {
	set body [info body ::Aliases::$name]
	set args [info args ::Aliases::$name]
	namespace eval ::Aliases "proc ${name}COPY {$args} {$body}"
	makelist
	post
	save
	edit ${name}COPY
}
proc add {win} {
	catch {rename ::Aliases::[$win.name.old cget -text] {}}
	set name [$win.name.name get]
	set body [$win.cmd.text get 0.0 end]
	if {![string length $name] || ![string length $body]} {
		tk_dialog .error "Error" "Please provide and name for your alias." error 0 Okay
		return
	}
	namespace eval ::Aliases "proc $name {args} {$body}"
	makelist
	post
	destroy $win
	save
}
proc edit {which} {
	set win [toplevel .[new]]
	frame $win.name
	label $win.name.label -text "Alias name" -anchor w
	label $win.name.old -text $which
	entry $win.name.name
	bind $win.name.name <space> {break}
	$win.name.name insert end $which
	pack $win.name.label -side left -fill x -expand true
	pack $win.name.name -side left
	bind $win.name.name <Return> {focus [tk_focusNext %W]}
	pack $win.name -side top -fill x
	label $win.lab -text "Alias body" -anchor w
	pack $win.lab -side top -fill x
	ScrolledTextWidget $win.cmd -width 80 -height 15
	pack $win.cmd -side top -fill both -expand true
	frame $win.but
	button $win.but.save -text Save -command "::Alias::add $win"
	button $win.but.al -text "Alias Help" -command "faq ALS"
	button $win.but.help -text "Scripting Help" -command "faq TCODE"
	button $win.but.can -text Cancel -command "destroy $win"
	pack $win.but.can -side right
	pack $win.but.help -side right
	pack $win.but.al -side right
	pack $win.but.save -side right
	pack $win.but -side top -fill x
	if ![string length $which] {
		$win.cmd.text insert end {# TkTurf now uses fully scripted aliases
# **DO NOT** put anything above these lines and
# do not delete this section unless you really
# know what you are doing
set i 1
foreach of $args {
	set $i $of
	incr i
}
for {} {$i <= 10} {incr i} {
	set $i {}
}
catch {unset of}
# end reserved section
# You may enter your script below this line
}
} {$win.cmd.text insert end [info body ::Aliases::$which]}
	center $win
	focus $win.name.name
	bind $win <Escape> "destroy $win"
}
}
proc AboutTkTurf {} {
	global VERSION
	destroy .abouttkturf
	toplevel .abouttkturf
	wm title .abouttkturf "About TkTurf"
	label .abouttkturf.label -text "TkTurf v$VERSION" -takefocus 0
	label .abouttkturf.fjack -text "Originally by Fastjack <fastjack@fastjack.turf.org>" -takefocus 0
	label .abouttkturf.nog -text "Additional improvements by Nog" -takefocus 0
	label .abouttkturf.mango -text "Clever Ideas & Coding by Mango"
	label .abouttkturf.beta -text "Beta Testing by Mango" -takefocus 0
	label .abouttkturf.code -text "Code support by: Ali, & Ninja" -takefocus 0
	label .abouttkturf.thanks -text "Special thanks to Mtf for Turf support and extension" -takefocus 0
	label .abouttkturf.lic -text "This program is released under the GNU General\nPublic License v2, or at your option any\nlater version.  All terms and conditions apply."
	pack .abouttkturf.label -side top -fill x -padx 10 -pady 10
	pack .abouttkturf.fjack -side top -fill x
	pack .abouttkturf.nog -side top -fill x
	pack .abouttkturf.mango -side top -fill x
	pack .abouttkturf.beta -side top -fill x
	pack .abouttkturf.thanks -side top -fill x
	pack .abouttkturf.code -side top -fill x
	pack .abouttkturf.lic -side top -fill x
	frame .abouttkturf.done
	button .abouttkturf.done.cancel -text "So what" -command {destroy .abouttkturf}
	pack .abouttkturf.done.cancel 
	pack .abouttkturf.done -side top -fill x -expand true -padx 5 -pady 5
	focus .abouttkturf.done.cancel
	bind .abouttkturf <Escape> {destroy .abouttkturf}
	center .abouttkturf
}
proc Copy {} {
	clipboard clear
	catch {clipboard append [selection get]}
}
proc Paste {win} {
	if [catch {$win insert insert [selection get -selection PRIMARY]}] {
		catch {$win insert insert [selection get -selection CLIPBOARD]}
	}
}
proc ConnectErrorWin {} {
	catch {Prompt::show "Error connecting"}
	set choice [tk_dialog .cew "Connection Problem" "There was an error connecting.\nWhat would you like to do?" error 0 Retry Ignore "Sod it" "Configure a Proxy"]
	if {$choice == 0} {
		update idletasks
		GetSock
		return
	}
	if {$choice == 1} {
		return
	}
	if {$choice == 2} {
		exit
	}
	if {$choice == 3} {
		Preferences::window
		tkwait window .prefs
		update idletasks
		GetSock
	}
}
proc colset {colour} {
	set new [tk_chooseColor -initialcolor $colour]
	if {[string length $new] > 0} {
		return $new
	} {
		return $colour
	}
}
proc GCCW {} {
	destroy .ccw
	toplevel .ccw
	wm title .ccw "Amusements colours"
	frame .ccw.c
	canvas .ccw.c.canvas -width 10 -height 10 -yscrollcommand [list .ccw.c.yscroll set]
	scrollbar .ccw.c.yscroll -orient vertical -command [list .ccw.c.canvas yview]
	pack .ccw.c.yscroll -side right -fill y
	pack .ccw.c.canvas -side left -fill both -expand true
	pack .ccw.c -side top -fill both -expand true
	frame .ccw.c.canvas.f -bd 0
	.ccw.c.canvas create window 0 0 -anchor nw -window .ccw.c.canvas.f
	button .ccw.c.canvas.f.cfyellow -text "Connect 4 Yellow" -command {set ::COLOURS(CFYELLOW) [colset $::COLOURS(CFYELLOW)];.ccw.c.canvas.f.cfyellow config -background $::COLOURS(CFYELLOW)} -background $::COLOURS(CFYELLOW)
	button .ccw.c.canvas.f.cfred -text "Connect 4 Red" -command {set ::COLOURS(CFRED) [colset $::COLOURS(CFRED)];.ccw.c.canvas.f.cfred config -background $::COLOURS(CFRED)} -background $::COLOURS(CFRED)
	button .ccw.c.canvas.f.cfbg -text "Connect 4 Background" -command {set ::COLOURS(CFBG) [colset $::COLOURS(CFBG)]; .ccw.c.canvas.f.cfbg config -background $::COLOURS(CFBG)} -background $::COLOURS(CFBG)
	button .ccw.c.canvas.f.cfblank -text "Connect 4 Blank" -command {set ::COLOURS(CFBLANK) [colset $::COLOURS(CFBLANK)];.ccw.c.canvas.f.cfblank config -background $::COLOURS(CFBLANK)} -background $::COLOURS(CFBLANK)
	button .ccw.c.canvas.f.cfout -text "Connect 4 Highlight" -command {set ::COLOURS(CFOUT) [colset $::COLOURS(CFOUT)];.ccw.c.canvas.f.cfout config -background $::COLOURS(CFOUT)} -background $::COLOURS(CFOUT)
	button .ccw.c.canvas.f.cblack -text "Chess South Pieces" -command {set ::COLOURS(CBLACK) [colset $::COLOURS(CBLACK)]; .ccw.c.canvas.f.cblack config -background $::COLOURS(CBLACK)} -background $::COLOURS(CBLACK)
	button .ccw.c.canvas.f.cwhite -text "Chess North Pieces" -command {set ::COLOURS(CWHITE) [colset $::COLOURS(CWHITE)]; .ccw.c.canvas.f.cwhite config -background $::COLOURS(CWHITE)} -background $::COLOURS(CWHITE)
	button .ccw.c.canvas.f.check1 -text "Check1 colour" -command {set ::COLOURS(CHECK1) [colset $::COLOURS(CHECK)1]; .ccw.c.canvas.f.check1 config -background $::COLOURS(CHECK)1} -background $::COLOURS(CHECK)1
	button .ccw.c.canvas.f.check2 -text "Check2 colour" -command {set ::COLOURS(CHECK2) [colset $::COLOURS(CHECK)2]; .ccw.c.canvas.f.check2 config -background $::COLOURS(CHECK)2} -background $::COLOURS(CHECK)2
	button .ccw.c.canvas.f.chl -text "Selected Piece colour" -command {set ::COLOURS(CHESSHL) [colset $::COLOURS(CHESSHL)]; .ccw.c.canvas.f.chl config -background $::COLOURS(CHESSHL)} -background $::COLOURS(CHESSHL)	
	button .ccw.c.canvas.f.rred -text "Reversi Red" -command {set ::COLOURS(RRED) [colset $::COLOURS(RRED)]; .ccw.c.canvas.f.rred config -background $::COLOURS(RRED)} -background $::COLOURS(RRED)
	button .ccw.c.canvas.f.rblue -text "Reversi Blue" -command {set ::COLOURS(RBLUE) [colset $::COLOURS(RBLUE)]; .ccw.c.canvas.f.rblue config -background $::COLOURS(RBLUE)} -background $::COLOURS(RBLUE)
	button .ccw.c.canvas.f.rback -text "Reversi Background" -command {set ::COLOURS(RBACK) [colset $::COLOURS(RBACK)]; .ccw.c.canvas.f.rback config -background $::COLOURS(RBACK)} -background $::COLOURS(RBACK)
	button .ccw.c.canvas.f.rlines -text "Reversi Lines" -command {set ::COLOURS(RLINES) [colset $::COLOURS(RLINES)]; .ccw.c.canvas.f.rlines config -background $::COLOURS(RLINES)} -background $::COLOURS(RLINES)
	button .ccw.c.canvas.f.bsmis -text "Battleship Miss" -command {set ::COLOURS(BSMIS) [colset $::COLOURS(BSMIS)]; .ccw.c.canvas.f.bsmis config -background $::COLOURS(BSMIS)} -background $::COLOURS(BSMIS)
	button .ccw.c.canvas.f.bshit -text "Battleship Hit" -command {set ::COLOURS(BSHIT) [colset $::COLOURS(BSHIT)]; .ccw.c.canvas.f.bshit config -background $::COLOURS(BSHIT)} -background $::COLOURS(BSHIT)
	button .ccw.c.canvas.f.shipcol -text "Battleship Ships" -command {set ::COLOURS(SHIPCOL) [colset $::COLOURS(SHIPCOL)]; .ccw.c.canvas.f.shipcol config -background $::COLOURS(SHIPCOL)} -background $::COLOURS(SHIPCOL)
	button .ccw.c.canvas.f.bswcol -text "Battleship Water" -command {set ::COLOURS(BSWCOL) [colset $::COLOURS(BSWCOL)]; .ccw.c.canvas.f.bswcol config -background $::COLOURS(BSWCOL)} -background $::COLOURS(BSWCOL)
	button .ccw.c.canvas.f.bslcol -text "Battleship Grid" -command {set ::COLOURS(BSLCOL) [colset $::COLOURS(BSLCOL)]; .ccw.c.canvas.f.bslcol config -background $::COLOURS(BSLCOL)} -background $::COLOURS(BSLCOL)
	button .ccw.c.canvas.f.bsoutl -text "Ship Outlines" -command {set ::COLOURS(BSOUTL) [colset $::COLOURS(BSOUTL)]; .ccw.c.canvas.f.bsoutl config -background $::COLOURS(BSOUTL)} -background $::COLOURS(BSOUTL)
	button .ccw.c.canvas.f.restore -text "Restore Preference colours" -command {Preferences::loadcolours; TTC .twid.text; TTC .filter.text; .twid.text config -background $::COLOURS(BG); .filter.text config -background $::COLOURS(BG); .filter.text config -foreground $::COLOURS(BLACK); .twid.text config -foreground $::COLOURS(BLACK);.ccw.c.canvas.f.cfyellow config -background $::COLOURS(CFYELLOW); .ccw.c.canvas.f.cfred config -background $::COLOURS(CFRED); .ccw.c.canvas.f.cfbg config -background $::COLOURS(CFBG); .ccw.c.canvas.f.cfblank config -background $::COLOURS(CFBLANK); .ccw.c.canvas.f.cfout config -background $::COLOURS(CFOUT); .ccw.c.canvas.f.cblack config -background $::COLOURS(CBLACK); .ccw.c.canvas.f.chl config -background $::COLOURS(CHESSHL); .ccw.c.canvas.f.check2 config -background $::COLOURS(CHECK)2; .ccw.c.canvas.f.check1 config -background $::COLOURS(CHECK)1; .ccw.c.canvas.f.cwhite config -background $::COLOURS(CWHITE); .ccw.c.canvas.f.rred config -background $::COLOURS(RRED); .ccw.c.canvas.f.rblue config -background $::COLOURS(RBLUE); .ccw.c.canvas.f.rback config -background $::COLOURS(RBACK); .ccw.c.canvas.f.rlines config -background $::COLOURS(RLINES); .ccw.c.canvas.f.bsmis config -background $::COLOURS(BSMIS); .ccw.c.canvas.f.bshit config -background $::COLOURS(BSHIT); .ccw.c.canvas.f.shipcol config -background $::COLOURS(SHIPCOL); .ccw.c.canvas.f.bswcol config -background $::COLOURS(BSWCOL); .ccw.c.canvas.f.bslcol config -background $::COLOURS(BSLCOL);.ccw.c.canvas.f.bsoutl config -background $::COLOURS(BSOUTL)}
	button .ccw.c.canvas.f.def -text "Restore Default colours" -command {Preferences::setcoldefaults; TTC .twid.text; TTC .filter.text; .ccw.c.canvas.f.cblack config -background $::COLOURS(CBLACK); .ccw.c.canvas.f.chl config -background $::COLOURS(CHESSHL); .ccw.c.canvas.f.check2 config -background $::COLOURS(CHECK)2; .ccw.c.canvas.f.check1 config -background $::COLOURS(CHECK)1; .ccw.c.canvas.f.cwhite config -background $::COLOURS(CWHITE); .filter.text config -background $::COLOURS(BG); .filter.text config -foreground $::COLOURS(BLACK);.twid.text config -background #d9d9d9; .twid.text config -foreground #000000; .ccw.c.canvas.f.cfyellow config -background $::COLOURS(CFYELLOW); .ccw.c.canvas.f.cfred config -background $::COLOURS(CFRED); .ccw.c.canvas.f.cfbg config -background $::COLOURS(CFBG); .ccw.c.canvas.f.cfblank config -background $::COLOURS(CFBLANK); .ccw.c.canvas.f.cfout config -background $::COLOURS(CFOUT); .ccw.c.canvas.f.rred config -background $::COLOURS(RRED); .ccw.c.canvas.f.rblue config -background $::COLOURS(RBLUE); .ccw.c.canvas.f.rback config -background $::COLOURS(RBACK); .ccw.c.canvas.f.rlines config -background $::COLOURS(RLINES); .ccw.c.canvas.f.bsmis config -background $::COLOURS(BSMIS); .ccw.c.canvas.f.bshit config -background $::COLOURS(BSHIT); .ccw.c.canvas.f.shipcol config -background $::COLOURS(SHIPCOL); .ccw.c.canvas.f.bswcol config -background $::COLOURS(BSWCOL); .ccw.c.canvas.f.bslcol config -background $::COLOURS(BSLCOL);.ccw.c.canvas.f.bsoutl config -background $::COLOURS(BSOUTL)}
	grid .ccw.c.canvas.f.cfyellow
	grid .ccw.c.canvas.f.cfyellow -sticky we
	grid .ccw.c.canvas.f.cfred -sticky we
	grid .ccw.c.canvas.f.cfbg -sticky we
	grid .ccw.c.canvas.f.cfblank -sticky we
	grid .ccw.c.canvas.f.cfout -sticky we
	grid .ccw.c.canvas.f.cwhite -sticky we
	grid .ccw.c.canvas.f.cblack -sticky we
	grid .ccw.c.canvas.f.chl -sticky we
	grid .ccw.c.canvas.f.check1 -sticky we
	grid .ccw.c.canvas.f.check2 -sticky we
	grid .ccw.c.canvas.f.rred -sticky we
	grid .ccw.c.canvas.f.rblue -sticky we
	grid .ccw.c.canvas.f.rback -sticky we
	grid .ccw.c.canvas.f.rlines -sticky we
	grid .ccw.c.canvas.f.bsmis -sticky we
	grid .ccw.c.canvas.f.bshit -sticky we
	grid .ccw.c.canvas.f.shipcol -sticky we
	grid .ccw.c.canvas.f.bswcol -sticky we
	grid .ccw.c.canvas.f.bslcol -sticky we
	grid .ccw.c.canvas.f.bsoutl -sticky we
	grid .ccw.c.canvas.f.restore -sticky we
	grid .ccw.c.canvas.f.def -sticky we
	bind .ccw <Escape> {destroy .ccw}
	if {$::REVOPP != -1} {
		.ccw.c.canvas.f.rred config -state disabled
		.ccw.c.canvas.f.rblue config -state disabled
		.ccw.c.canvas.f.rback config -state disabled
		.ccw.c.canvas.f.rlines config -state disabled
	}
	tkwait visibility .ccw.c.canvas.f.cfyellow
	set bbox [grid bbox .ccw.c.canvas.f 0 0]
	set incr [lindex $bbox 3]
	set width [winfo reqwidth .ccw.c.canvas.f]
	set height [winfo reqheight .ccw.c.canvas.f]
	.ccw.c.canvas config -scrollregion "0 0 $width $height"
	.ccw.c.canvas config -yscrollincrement $incr
	set height [expr 7 * $incr]
	.ccw.c.canvas config -width $width -height $height
	wm protocol .ccw WM_DELETE_WINDOW {::Preferences::savecolours; destroy .ccw}
}
proc CCW {} {
	destroy .ccw
	toplevel .ccw
	wm title .ccw "colour Configurator"
	button .ccw.black -text Black -command {set ::COLOURS(BLACK) [colset $::COLOURS(BLACK)]; .twid.text config -foreground $::COLOURS(BLACK); .ccw.black config -background $::COLOURS(BLACK);.filter.text config -foreground $::COLOURS(BLACK);} -background $::COLOURS(BLACK)
	button .ccw.red -text Red -command {set ::COLOURS(RED) [colset $::COLOURS(RED)]; TTC .twid.text; TTC .filter.text; .ccw.red config -background $::COLOURS(RED)} -background $::COLOURS(RED)
	button .ccw.green -text Green -command {set ::COLOURS(GREEN) [colset $::COLOURS(GREEN)]; TTC .twid.text; TTC .filter.text; .ccw.green config -background $::COLOURS(GREEN)} -background $::COLOURS(GREEN)
	button .ccw.yellow -text Yellow -command {set ::COLOURS(YELLOW) [colset $::COLOURS(YELLOW)]; TTC .twid.text; TTC .filter.text; .ccw.yellow config -background $::COLOURS(YELLOW)} -background $::COLOURS(YELLOW)
	button .ccw.blue -text Blue -command {set ::COLOURS(BLUE) [colset $::COLOURS(BLUE)]; TTC .twid.text; TTC .filter.text; .ccw.blue config -background $::COLOURS(BLUE)} -background $::COLOURS(BLUE)
	button .ccw.magenta -text Magenta -command {set ::COLOURS(MAGENTA) [colset $::COLOURS(MAGENTA)];TTC .twid.text; TTC .filter.text;.ccw.magenta config -background $::COLOURS(MAGENTA)} -background $::COLOURS(MAGENTA)
	button .ccw.cyan -text Cyan -command {set ::COLOURS(CYAN) [colset $::COLOURS(CYAN)];TTC .twid.text; TTC .filter.text; .ccw.cyan config -background $::COLOURS(CYAN)} -background $::COLOURS(CYAN)
	button .ccw.white -text White -command {set ::COLOURS(WHITE) [colset $::COLOURS(WHITE)];TTC .twid.text; TTC .filter.text;.ccw.white config -background $::COLOURS(WHITE)} -background $::COLOURS(WHITE)
	button .ccw.sel -text "Text Selection" -command {set ::COLOURS(::COLOURS(SELECT)) [colset $::COLOURS(SELECT)]; TTC .twid.text; TTC .filter.text; .ccw.sel config -background $::COLOURS(SELECT)} -background $::COLOURS(SELECT)
	button .ccw.bg -text "Turf Window Background" -command {set ::COLOURS(BG) [colset $::COLOURS(BG)]; catch {.twid.text config -background $::COLOURS(BG)}; .ccw.bg config -background $::COLOURS(BG); .filter.text config -background $::COLOURS(BG)} -background $::COLOURS(BG)
	button .ccw.restore -text "Restore Preference colours" -command {catch {Preferences::setcoldefaults; Preferences::loadcolours; TTC .twid.text; TTC .filter.text;.filter.text config -background $::COLOURS(BG); .filter.text config -foreground $::COLOURS(BLACK); .twid.text config -background $::COLOURS(BG); .twid.text config -foreground $::COLOURS(BLACK); .ccw.black config -background $::COLOURS(BLACK); .ccw.red config -background $::COLOURS(RED); .ccw.green config -background $::COLOURS(GREEN); .ccw.yellow config -background $::COLOURS(YELLOW); .ccw.blue config -background $::COLOURS(BLUE); .ccw.magenta config -background $::COLOURS(MAGENTA); .ccw.cyan config -background $::COLOURS(CYAN); .ccw.white config -background $::COLOURS(WHITE);.ccw.bg config -background $::COLOURS(BG);.filter.text config -background $::COLOURS(BG); .filter.text config -foreground $::COLOURS(BLACK);.filter.text config -background $::COLOURS(BG); .filter.text config -foreground $::COLOURS(BLACK); .ccw.sel config -background $::COLOURS(SELECT)}}
	button .ccw.def -text "Restore Default colours" -command {catch {Preferences::setcoldefaults; TTC .twid.text; TTC .filter.text;.filter.text config -background $::COLOURS(BG); .filter.text config -foreground $::COLOURS(BLACK); .twid.text config -background #d9d9d9; .twid.text config -foreground #000000; .ccw.black config -background $::COLOURS(BLACK); .ccw.red config -background $::COLOURS(RED); .ccw.green config -background $::COLOURS(GREEN); .ccw.yellow config -background $::COLOURS(YELLOW); .ccw.blue config -background $::COLOURS(BLUE); .ccw.magenta config -background $::COLOURS(MAGENTA); .ccw.cyan config -background $::COLOURS(CYAN); .ccw.white config -background $::COLOURS(WHITE);.ccw.bg config -background $::COLOURS(BG);.ccw.sel config -background $::COLOURS(SELECT)}}
	pack .ccw.black -side top -fill x
	pack .ccw.red -side top -fill x
	pack .ccw.green -side top -fill x
	pack .ccw.yellow -side top -fill x
	pack .ccw.blue -side top -fill x
	pack .ccw.magenta -side top -fill x
	pack .ccw.cyan -side top -fill x
	pack .ccw.white -side top -fill x
	if {$::tcl_platform(platform) == "windows"} {
		pack .ccw.sel -side top -fill x
	}
	pack .ccw.bg -side top -fill x
	pack .ccw.restore -side top -fill x
	pack .ccw.def -side top -fill x
	bind .ccw <Escape> {destroy .ccw}
	wm protocol .ccw WM_DELETE_WINDOW {::Preferences::savecolours; destroy .ccw}
}
proc fread {} {
	global finger
	global fbuffer
	if [eof $finger] {
		catch {close $finger}
		if [string length $fbuffer] {
			catch {wintalk .twid.text "\n$fbuffer\n" {}}
		}
		catch {unset fbuffer}
		return
	}
	if [catch {append fbuffer [read $finger]}] {
		catch {close $finger}
		catch {unset fbuffer}
		tk_dialog .error "Error" "Error: finger connection refused" error 0 Okay
	}
}
proc finfo {} {
	set who [.finger.who get]
	finger $who
}
proc finger {who} {
	global tprime
	global finger
	global fbuffer
	if {[regexp "@" $who] == 0} {
		catch {puts $tprime "finger $who"}
		destroy .finger
		return
	}
	regsub "@\[^@\]*$" $who {} name
	regsub ".*@" $who {} site
	if ![string length $site] {
		tk_dialog .error "Error" "Error: no host given to finger" error 0 Cancel
		return
	}
	if [catch {socket -async $site 79} finger] {
		tk_dialog .error Error "Error: could not resolve host" error 0 Okay
	}
	fconfigure $finger -buffersize 1 -buffering none -blocking 0
	fileevent $finger readable fread
	catch {puts $finger $name}
	destroy .finger
}
proc FW {} {
	destroy .finger
	toplevel .finger
	wm title .finger Finger
	label .finger.label -text "Finger who?" -takefocus 0
	entry .finger.who
	bind .finger.who <Return> {finfo}
	pack .finger.label -side top -fill x
	pack .finger.who -side top -fill x
	focus .finger.who
	bind .finger <Escape> {destroy .finger}
	center .finger
}
proc descpost {} {
	global tprime
	if [catch { puts $tprime \n }] { tk_dialog .nomail Error "You can not change your description without being connected." error 0 "Oh yeah...";  return}
	puts -nonewline $tprime "description "
	set lineout [.desc.desc.text get 0.0 end]
	regsub -all "\n" $lineout { } lineout
	regsub -all "  *" $lineout { } lineout
	puts $tprime $lineout
	destroy .desc
}
proc DEW {} {
	destroy .desc
	toplevel .desc
	wm title .desc "Description Editor"
	ScrolledTextWidget .desc.desc -width 60 -height 9 -wrap word
	pack .desc.desc -side top -fill both -expand true
	frame .desc.but
	button .desc.but.ch -text Change -command "descpost"
	button .desc.but.cancel -text Cancel -command "destroy .desc"
	pack .desc.but -side top -fill x
	pack .desc.but.cancel -side right
	pack .desc.but.ch -side right
	bind .desc.desc.text <Return> {break}
	focus .desc.desc.text
	bind .desc <Escape> "destroy .desc"
	center .desc
	set id [new]
	puts $::tprime "c15 h$id description"
	Capture::addID $id showdesc
}
proc showdesc {data} {
	set desc [.desc.desc.text get 0.0 end]
	append desc $data
	regsub "Your description is:\n" $desc {} desc
	regsub -all \n $desc { } desc
	regsub -all " +" $desc { } desc
	regsub "^ " $desc {} desc
	.desc.desc.text delete 0.0 end
	.desc.desc.text insert end $desc
}
namespace eval RoomEdit {
proc send {widget} {
	global tprime
	if [catch { puts $tprime \n }] { tk_dialog .nomail Error "You can not change your room without being connected." error 0 "Oh yeah...";  return}
	puts $tprime "c15 hdud roomedit"
	puts $tprime ".wipe"
	set message [$widget.red.text get 0.0 end]
	foreach of [lreplace [split $message \n] end end] {
		if ![string length $of] {set of {  }}
		puts $tprime $of
		after 250
	}
	puts $tprime ".end"
	destroy $widget
}
proc window {} {
	global winc
	incr winc
	toplevel .$winc
	wm title .$winc "Room Editor"
	ScrolledTextWidget .$winc.red -width 60 -height 9 -wrap word
	pack .$winc.red -side top -fill both -expand true
	frame .$winc.but
	button .$winc.but.ch -text Change -command "RoomEdit::send .$winc"
	button .$winc.but.cancel -text Cancel -command "destroy .$winc"
	pack .$winc.but -side top -fill x
	pack .$winc.but.cancel -side right
	pack .$winc.but.ch -side right
	focus .$winc.red.text
	bind .$winc <Escape> "destroy .$winc"
	::Capture::addID $winc ::RoomEdit::load
	puts $::tprime "c15 h$winc roomedit"
	center .$winc
	set ::ROOMD {}
}
proc load {data} {
	if [regexp "You can only edit your home room\." $data] {
		destroy .$::CMD_ID
		tk_dialog .error "Error" "You must be in your home to edit it." error 0 Okay
		return
	}
	if [regexp "Entering editor \.\.\. Use '\.help' for help\." $data] {return}
	if [regexp "'/<command>' for general commands, '.<command>' for editor commands." $data] {return}
	if [regexp "Use '.end' to finish and keep edit." $data] {return}
	if [regexp "Used .* bytes out of .*, in .* lines and .* words." $data] {
		puts $::tprime ".quit"
		set win ".$::CMD_ID.red.text"
		regsub -all "\n    " $::ROOMD { } ::ROOMD
		regsub "\n*$" $::ROOMD {} ::ROOMD
		$win delete 0.0 end
		$win insert end $::ROOMD
		unset ::ROOMD
		return
	}
	append ::ROOMD $data
}
}
proc Pcheck {wid} {
	if {[string compare $::PREFS(PASSWD) [$wid.epw get]] == 0} {
		bind $wid <Destroy> {break}
		grab release $wid
		destroy $wid
		catch {.twid.text see end}
	} {
		$wid.epw delete 0 end
		$wid config -cursor pirate
		after 1000 "$wid config -cursor dot"
		return
	}
}
proc PP {} {
	destroy .pprompt
	toplevel .pprompt
	wm title .pprompt "Password Prompt"
	label .pprompt.query -text "Lock under what password?"
	entry .pprompt.pass -show *
	pack .pprompt.query -side top -fill x
	pack .pprompt.pass -side top -fill x
	bind .pprompt.pass <Return> {set ::PREFS(PASSWD) [.pprompt.pass get]; destroy .pprompt}
	bind .pprompt <Escape> {destroy .pprompt}
	center .pprompt
	grab .pprompt.pass
	focus -force .pprompt.pass
	tkwait window .pprompt
}
proc LT {bit} {
	global winc
	update idletasks
	if {[string length $::PREFS(PASSWD)] < 1} {
		PP
	}
	if {[string length $::PREFS(PASSWD)] < 1} {return}
	if {$bit == 1} {
		catch {.twid.text see 0.0}
	}
	incr winc
	toplevel .$winc
	wm title .$winc "Password"
	label .$winc.pw -text Password
	entry .$winc.epw -show *
	pack .$winc.pw -side left
	pack .$winc.epw -side left -fill x
	bind .$winc <Return> "Pcheck .$winc"
	bind .$winc <Destroy> {break}
	bind .$winc <Control-Key-s> {break}
	bind .$winc <Control-Key-q> {break}
	bind .$winc <Meta-Key-q> {break}
	bind .$winc <Control-Key-z> {break}
	wm protocol .$winc WM_DELETE_WINDOW {break}
	center .$winc
	focus -force .$winc.epw
	if {[catch {grab -global .$winc}]} {
		catch {grab .$winc}
	}
	bind .$winc <FocusOut> "focus -force .$winc.epw"
	.$winc config -cursor dot
	tkwait window .$winc
}
proc LDump {} {
	if {$::PREFS(FILTER) == 0} {set win 0} {
		set win [tk_dialog .error "Which Window" "Which window would you like to dump to a log file?" question 0 Main "Filter Window" Cancel]
	}
	if {$win == 2} {return}
	if {$win == 0} {set win .twid.text} {set win .filter.text}
	set fname [getSaveFile]
	if {[string length $fname] == 0} {return}
	set file [open $fname w]
	puts $file [$win get 0.0 end]
	close $file
}
namespace eval Preferences {
set hooks {}
set applys {}
proc addHook {function} {
	lappend ::Preferences::hooks $function
}
proc removeHook {function} {
	set index [lsearch $::Preferences::hooks $function]
	if {$index == -1} {return}
	set ::Preferences::hooks [lreplace $::Preferences::hooks $index $index]
}
proc addApply {function} {
	lappend ::Preferences::applys $function
}
proc removeApply {function} {
	set index [lsearch $::Preferences::applys $function]
	if {$index == -1} {return}
	set ::Preferences::applys [lreplace $::Preferences::applys $index $index]
}
proc save {} {
	set file [Preferences::writeopen]
	if {[string compare $file "NULL"] == 0} {
		return
	}
	foreach of [array names ::PREFS] {
		puts $file "set {::PREFS($of)} {$::PREFS($of)}"
	}
	foreach of [array names ::soundnames] {
		puts $file "set {::soundnames($of)} {$::soundnames($of)}"
	}
	foreach of [array names ::SOUNDSTUB] {
		puts $file "set {::SOUNDSTUB($of)} {$::SOUNDSTUB($of)}"
	}
	close $file
}
proc apply {} {
	set ::PREFS(FSIZE) [expr round($::PREFS(FSIZE))]
	set ::PREFS(FONT) "\"$::PREFS(FFACE)\" $::PREFS(FSIZE)"
	ApplySetting . font $::PREFS(FONT)
	option add *font $::PREFS(FONT)
	.twid.yscroll config -width $::PREFS(SWIDTH)
	.filter.yscroll config -width $::PREFS(SWIDTH)
	pack forget .promptline
	pack forget .promptline.mainent
	::Prompt::unpack
	pack forget .promptline.tray
	pack .promptline.tray -side right
	pack .promptline.mainent -side right -fill x -expand true
	::Prompt::pack
	pack forget .twid
	pack forget .filter
	pack .promptline -side bottom -fill x
	bind .promptline.mainent <Return> {STDre .promptline.mainent}
	if {$::PREFS(FILTER) == 1} {
		pack .filter -side bottom -fill both -expand true
	} {
		undump .twid.text [.filter.text dump 0.0 end]
		.filter.text config -state normal
		.filter.text delete 0.0 end
		.filter.text config -state disabled
	}
	.filter.text config -height $::PREFS(FILTERSIZE)
	pack .twid -side bottom -fill both -expand true
	.twid.text see end
	focus -force .promptline.mainent
	bind . <Up> {EntScroll 1}
	bind . <Down> {EntScroll 0}
	bind all <Control-Key-p> {EntScroll 1}
	bind all <Control-Key-n> {EntScroll 0}
	bind all <Control-Key-u> {.promptline.mainent delete 0 end}
	bind all <Control-Key-q> {quit}
	bind all <Control-Key-l> {LT 1}
	bind .promptline.mainent <Shift-Return> {.promptline.mainent insert insert "\n\r"; break}
	bind .promptline.mainent <Tab> {catch {TabGrep}; break}
	bind . <FocusIn> {SetDoNotify VisibilityUnobscured}
	bind . <FocusOut> {SetDoNotify VisibilityFullyObscured}
	bind . <Next> {.twid.text yview scroll 1 pages}
	bind . <Prior> {.twid.text yview scroll -1 pages}
	bind . <Shift-Next> {.filter.text yview scroll 1 pages; break}
	bind . <Shift-Prior> {.filter.text yview scroll -1 pages; break}
	bind . <Control-Next> {.twid.text see end}
	bind . <Control-Prior> {.twid.text see 0.0}
	bind . <Control-Shift-Next> {.filter.text see end}
	bind . <Control-Shift-Prior> {.filter.text see 0.0}
	TTC .twid.text
	TTC .filter.text
	.twid.text see end
	.filter.text see end
	if {$::PREFS(MENU) == 1} {. config -menu .menubar} {. config -menu {}}
	if {($::PREFS(CHESSLOG) == 1) && ([winfo exists .chess])} {
		pack forget .chess.mess
		pack .chess.log -side top -fill x -expand true
		pack .chess.mess -side top -fill x -expand true
	}
	if {($::PREFS(CHESSLOG) == 0) && ([winfo exists .chess])} {
		pack forget .chess.log
	}
	foreach of $::Preferences::applys {
		if [catch {eval [info body $of]}] {puts $::errorInfo}
	}
}
proc setcoldefaults {} {
	set ::COLOURS(SELECT) #bbbbbb
	set ::COLOURS(BSOUTL) red
	set ::COLOURS(BSLCOL) black
	set ::COLOURS(SHIPCOL) #a9a9a9
	set ::COLOURS(BSWCOL) lightblue
	set ::COLOURS(BSHIT) red
	set ::COLOURS(BSMIS) white
	set ::COLOURS(RBACK) grey
	set ::COLOURS(RLINES) black
	set ::COLOURS(RRED) red
	set ::COLOURS(RBLUE) blue
	set ::COLOURS(CWHITE) white
	set ::COLOURS(CBLACK) black
	set ::COLOURS(CHECK1) #5b7ed0
	set ::COLOURS(CHECK2) #4f49b4
	set ::COLOURS(CFOUT) green
	set ::COLOURS(BLACK) black
        set ::COLOURS(GREEN) green
        set ::COLOURS(RED) red
        set ::COLOURS(YELLOW) yellow
        set ::COLOURS(BLUE) blue
        set ::COLOURS(CYAN) cyan
        set ::COLOURS(MAGENTA) magenta
        set ::COLOURS(WHITE) white
        set ::COLOURS(CFYELLOW) yellow
        set ::COLOURS(CFRED) red
        set ::COLOURS(CFBG) blue
        set ::COLOURS(CFBLANK) black
	set ::COLOURS(BG) #d9d9d9
	set ::COLOURS(CHESSHL) red
}
proc setdefaults {} {
	set ::PREFS(ALL) 1
	set ::QUIT 0
	set ::PREFS(CASETAB) 0
	set ::PREFS(CHESSLOG) 1
	set ::PREFS(CKQUIT) 0
	set ::PREFS(SAVESESSIONSTATE) 1
	set ::PREFS(LOGOUTONSAVE) 1
	set ::PREFS(FILTERSIZE) 6
	set ::soundnames(CHAL) {Game Challenge}
	set ::soundnames(START) {Start Sound}
	set ::soundnames(CFMOVE) {Connect 4 Move}
	set ::soundnames(CHMOVE) {Chess Move}
	set ::soundnames(RVMOVE) {Reversi Move}
	set ::soundnames(BSMISS) {Battleship Miss}
	set ::soundnames(BSHIT) {Battleship Hit}
	set ::soundnames(BSSINK) {Battleship Sink}
	set ::soundnames(CONNECT) {Connection}
	set ::soundnames(DISCONNECT) {Disconnection}
	set ::soundnames(CNECTERR) {Connection Error}
	set ::soundnames(BELL) {Beep Noise}
	set ::soundnames(NEWTEXT) {Message Notification}
	set ::SOUNDSTUB(CHAL) {}
	set ::SOUNDSTUB(NEWTEXT) {}
	set ::SOUNDSTUB(BELL) {}
	set ::SOUNDSTUB(CNECTERR) {}
	set ::SOUNDSTUB(START) {}
	set ::SOUNDSTUB(CFMOVE) {}
	set ::SOUNDSTUB(CHMOVE) {}
	set ::SOUNDSTUB(RVMOVE) {}
	set ::SOUNDSTUB(BSMISS) {}
	set ::SOUNDSTUB(BSHIT) {}
	set ::SOUNDSTUB(BSSINK) {}
	set ::SOUNDSTUB(CONNECT) {}
	set ::SOUNDSTUB(DISCONNECT) {}
	set ::PREFS(SOCKS) 0
	set ::PREFS(AUDIO) ""
	set ::PREFS(TABLIMIT) 100
	set ::PREFS(HTTPPROXY) ""
	set ::PREFS(HTTPPORT) 0
	set ::PREFS(CKV) 2
	set ::PREFS(NOTIFY) 1
	set ::PREFS(STIPPLE) 1
	set ::PREFS(RING) 1
	set ::PREFS(LOG) 0
	set ::PREFS(SWIDTH) 15
	set ::PREFS(LOGIN) 1
	set ::PREFS(MENU) 1
	set ::PREFS(FFACE) fixed
	set ::PREFS(FSIZE) 12
	if {$::tcl_platform(platform) == "windows"} { set ::PREFS(FFACE) fixedsys } 
	if {$::tcl_platform(platform) == "macintosh"} { set ::PREFS(FFACE) Courier }
	set ::PREFS(FONT) "$::PREFS(FFACE) $::PREFS(FSIZE)"
}
proc loadcolours {} {
	notify "Loading Colours"
	catch {source [::File::get colours]}
}
proc savecolours {} {
	set file [::File::open colours w]
	if {[string compare $file "NULL"] == 0} {
		return
	}
	foreach of [array names ::COLOURS] {
		puts $file "set {::COLOURS($of)} {$::COLOURS($of)}"
	}
	close $file
}
proc writeopen {} {
	if ![catch {::File::open tkturfrc w} file] {
		return $file
	}
	tk_dialog .error Error "Error: could not open preferences for writing." error 0 Damn
	return "NULL"
}
proc window {} {
	global SOUNDSTUB
	global soundnames
	destroy .prefs
	toplevel .prefs -height 60 -width 60
	wm title .prefs Preferences
	ButtonNotebook::create .prefs.main Appearance Behaviour Net Sound Misc
	pack .prefs.main -side top -fill both -expand true
	set frame [ButtonNotebook::getnextpage .prefs.main]
	frame $frame.two
	label $frame.two.f -text "Font size" -anchor w
	entry $frame.two.font -textvariable ::PREFS(FSIZE) -width 2
	pack $frame.two.f -side left -fill x -expand true
	pack $frame.two.font -side left
	pack $frame.two -side top -fill x -expand true
	frame $frame.fface
	label $frame.fface.l -text "Font face" -anchor w
	eval {tk_optionMenu $frame.fface.face ::PREFS(FFACE)} [lsort [font families]]
	pack $frame.fface.l -side left -fill x -expand true
	pack $frame.fface.face -side left
	pack $frame.fface -side top -fill x -expand true
	frame $frame.fsize
	label $frame.fsize.label -text "Filter window size" -anchor w
	entry $frame.fsize.entry -textvariable ::PREFS(FILTERSIZE) -width 2
	pack $frame.fsize.label -side left -fill x -expand true
	pack $frame.fsize.entry -side left
	pack $frame.fsize -side top -fill x -expand true
	frame $frame.four
	label $frame.four.s -text "Scroll bar width" -anchor w
	entry $frame.four.scroll -width 3 -textvariable ::PREFS(SWIDTH)
	pack $frame.four.s -side left -fill x -expand true
	pack $frame.four.scroll -side left
	pack $frame.four -side top -fill x -expand true
	frame $frame.ital
	label $frame.ital.label -text "Use italics for flashing" -anchor w
	checkbutton $frame.ital.check -variable ::PREFS(ITALIC)
	pack $frame.ital.label -side left -fill x -expand true
	pack $frame.ital.check -side left
	pack $frame.ital -side top -fill x
	frame $frame.thi
	label $frame.thi.lab -text "Display menubar" -anchor w
	checkbutton $frame.thi.che -text "" -variable ::PREFS(MENU)
	pack $frame.thi.lab -side left -fill x -expand true
	pack $frame.thi.che -side left
	pack $frame.thi -side top -fill x -expand true
	frame $frame.nine
	label $frame.nine.label -text "Indicate last Connect4 move with grey" -anchor w
	checkbutton $frame.nine.yes -variable ::PREFS(STIPPLE) -text ""
	pack $frame.nine.label -side left -fill x -expand true
	pack $frame.nine.yes -side left
	pack $frame.nine -side top -fill x -expand true
	frame $frame.ten
	label $frame.ten.label -text "Circle last Connect4 move" -anchor w
	checkbutton $frame.ten.yes -variable ::PREFS(RING) -text ""
	pack $frame.ten.label -side left -fill x -expand true
	pack $frame.ten.yes -side left
	pack $frame.ten -side top -fill x -expand true
	frame $frame.chesslog
	label $frame.chesslog.lab -text "Display Chess move log" -anchor w
	checkbutton $frame.chesslog.check -variable ::PREFS(CHESSLOG) -text ""
	pack $frame.chesslog.lab -side left -fill x -expand true
	pack $frame.chesslog.check -side left
	pack $frame.chesslog -side top -fill x -expand true
	set frame [ButtonNotebook::getnextpage .prefs.main]
	frame $frame.one
	label $frame.one.l -text "Use Autologging" -anchor w
	checkbutton $frame.one.log -text "" -variable ::PREFS(LOG)
	pack $frame.one.l -side left -fill x -expand true
	pack $frame.one.log -side left
	pack $frame.one -side top -fill x -expand true
	frame $frame.ele
	label $frame.ele.lab -text "Use new message notification" -anchor w
	checkbutton $frame.ele.ch -variable ::PREFS(NOTIFY) -text ""
	pack $frame.ele.lab -side left -fill x -expand true
	pack $frame.ele.ch -side left
	pack $frame.ele -side top -fill x -expand true
	frame $frame.fil
	label $frame.fil.l -text "Filter flashing text to filter window" -anchor w
	checkbutton $frame.fil.ch -variable ::PREFS(FILTER) -text ""
	pack $frame.fil.l -side left -fill x -expand true
	pack $frame.fil.ch -side left
	pack $frame.fil -side top -fill x -expand true
	frame $frame.twe
	label $frame.twe.lab -text "Use Autologin" -anchor w
	checkbutton $frame.twe.che -text "" -variable ::PREFS(LOGIN)
	pack $frame.twe.lab -side left -fill x -expand true
	pack $frame.twe.che -side left
	pack $frame.twe -side top -fill x -expand true
	frame $frame.fou
	label $frame.fou.lab -text "Autologin defaults if only one entry" -anchor w
	checkbutton $frame.fou.che -variable ::PREFS(ALL) -text ""
	pack $frame.fou.lab -side left -fill x -expand true
	pack $frame.fou.che -side left
	pack $frame.fou -side top -fill x -expand true
	frame $frame.confirm
	label $frame.confirm.l -text "Confirm before quitting" -anchor w
	checkbutton $frame.confirm.con -variable ::PREFS(CKQUIT)
	pack $frame.confirm -side top -fill x
	pack $frame.confirm.l -side left -fill x -expand true
	pack $frame.confirm.con -side left
	frame $frame.hcaps
	label $frame.hcaps.l -text "Obey case when using tab history completion" -anchor w
	checkbutton $frame.hcaps.check -variable ::PREFS(CASETAB)
	pack $frame.hcaps -side top -fill x
	pack $frame.hcaps.l -side left -fill x -expand true
	pack $frame.hcaps.check -side left
	if {$::tcl_platform(platform) == "unix"} {
		frame $frame.gzip
		pack $frame.gzip -side top -fill x
		label $frame.gzip.label -anchor w -text "Gzipping"
		pack $frame.gzip.label -side left -fill x -expand true
		checkbutton $frame.gzip.bool -variable PREFS(gzip) -text "Compress"
		pack $frame.gzip.bool -side left
		label $frame.gzip.label2 -anchor e -width 6 -text {Level}
		pack $frame.gzip.label2 -side left
		entry $frame.gzip.level -width 1 -textvariable PREFS(gzlvl)
		pack $frame.gzip.level -side left
		frame $frame.gzexe
		pack $frame.gzexe -side top -fill x
		label $frame.gzexe.label -anchor w -text {Gzexe TkTurf}
		pack $frame.gzexe.label -side left -fill x -expand true
		checkbutton $frame.gzexe.check -variable PREFS(gzexe)
		pack $frame.gzexe.check -side left
	}
	frame $frame.hist
	label $frame.hist.l -text "Tab history-completion limit (larger == slower)" -anchor w
	entry $frame.hist.e -textvariable ::PREFS(TABLIMIT)
	pack $frame.hist.l -side left -fill x -expand true
	pack $frame.hist.e -side left
	pack $frame.hist -side top -fill x -expand true
	frame $frame.eight
	label $frame.eight.p -text "Session locking password" -anchor w
	entry $frame.eight.pass -show * -textvariable ::PREFS(PASSWD)
	pack $frame.eight.p -side left -fill x -expand true
	pack $frame.eight.pass -side left
	pack $frame.eight -side top -fill x -expand true
	set frame [ButtonNotebook::getnextpage .prefs.main]
	frame $frame.ckv
	label $frame.ckv.t -text "Check for and download new versions of TkTurf" -anchor w
	checkbutton $frame.ckv.check -text "" -variable ::PREFS(CKV)
	pack $frame.ckv -side top -fill x -expand true
	pack $frame.ckv.t -side left -fill x -expand true
	pack $frame.ckv.check -side left
	frame $frame.alpha
	label $frame.alpha.l -text "Download Alpha (test) versions of TkTurf" -anchor w
	checkbutton $frame.alpha.c -text "" -variable ::PREFS(USEALPHA)
	pack $frame.alpha.l -side left -fill x -expand true
	pack $frame.alpha.c -side left
	pack $frame.alpha -side top -fill x -expand true
	frame $frame.six
	label $frame.six.p -text "Proxy Address" -anchor w
	entry $frame.six.prox -textvariable ::PREFS(PROXY)
	pack $frame.six.p -side left -fill x -expand true
	pack $frame.six.prox -side left
	pack $frame.six -fill x -expand true -side top
	frame $frame.seven
	label $frame.seven.p -text "Proxy Port" -anchor w
	entry $frame.seven.port -textvariable ::PREFS(PROXYPORT)
	pack $frame.seven.p -side left -fill x -expand true
	pack $frame.seven.port -side left
	pack $frame.seven -side top -fill x -expand true
	frame $frame.socks
	frame $frame.socks.space
	checkbutton $frame.socks.check -text "SOCKS proxy" -variable ::PREFS(SOCKS)
	pack $frame.socks.space -side left -fill x -expand true
	pack $frame.socks.check -side left
	pack $frame.socks -side top -fill x -expand true
	frame $frame.ssh
	label $frame.ssh.lab -text "Datapipe Address" -anchor w
	entry $frame.ssh.ssh -textvariable ::PREFS(SSHHOST)
	pack $frame.ssh -side top -fill x -expand true
	pack $frame.ssh.lab -side left -fill x -expand true
	pack $frame.ssh.ssh -side left
	frame $frame.ssp
	label $frame.ssp.lab -text "Datapipe Port" -anchor w
	entry $frame.ssp.ent -textvariable ::PREFS(SSHPORT)
	pack $frame.ssp -side top -fill x -expand true
	pack $frame.ssp.lab -side left -fill x -expand true
	pack $frame.ssp.ent -side left
	frame $frame.http
	label $frame.http.t -text "HTTP Proxy Address" -anchor w
	entry $frame.http.ent -textvariable ::PREFS(HTTPPROXY)
	pack $frame.http.t -side left -fill x -expand true
	pack $frame.http.ent -side left
	pack $frame.http -side top -fill x -expand true
	frame $frame.htp
	label $frame.htp.t -text "HTTP Proxy Port" -anchor w
	entry $frame.htp.ent -textvariable ::PREFS(HTTPPORT)
	pack $frame.htp.t -side left -fill x -expand true
	pack $frame.htp.ent -side left
	pack $frame.htp -side top -fill x -expand true
	set frame [ButtonNotebook::getnextpage .prefs.main]
	frame $frame.player
	label $frame.player.l -text "Command line audio program for sound" -anchor w
	label $frame.player.audio -textvariable ::PREFS(AUDIO) -relief groove -width 45
	bind $frame.player.audio <Button> {::Sound::setaudio}
	frame $frame.help
	button $frame.help.help -text "Sound Help" -command {faq SOUND}
	pack $frame.player.l -side left -fill x -expand true
	pack $frame.player.audio -side left
	pack $frame.player -side top -fill x -expand true
	pack $frame.help -fill x
	pack $frame.help.help -side right
	foreach of [lsort -ascii [array names soundnames]] {
		set name [string tolower $of]
		frame $frame.$name
		label $frame.$name.label -text "$soundnames($of)" -anchor w
		label $frame.$name.sel -textvariable SOUNDSTUB($of) -relief groove -width 45
		bind $frame.$name.sel <Button> "::Sound::set $of"
		pack $frame.$name.label -side left -fill x -expand true
		pack $frame.$name.sel -side left
		pack $frame.$name -side top -fill x
	}
	frame .prefs.done
	button .prefs.done.ok -text "Ok" -command {Preferences::apply;Preferences::save;destroy .prefs} 
	button .prefs.done.apply -text "Apply" -command {Preferences::apply;Preferences::save}
	pack .prefs.done.apply -side right
	pack .prefs.done.ok -side right
	pack .prefs.done -side top -fill x
	bind .prefs <Escape> {Preferences::apply; Preferences::save;destroy .prefs}
	wm protocol .prefs WM_DELETE_WINDOW {Preferences::apply; Preferences::save; destroy .prefs}
	foreach of $::Preferences::hooks {
		if [catch {eval [info body $of]}] {puts $::errorInfo}
	}
	set frame [::ButtonNotebook::getpage .prefs.main 4]
	frame $frame.sss
	label $frame.sss.label -text "Enable session management" -anchor w
	checkbutton $frame.sss.check -variable ::PREFS(SAVESESSIONSTATE)
	pack $frame.sss.label -side left -fill x -expand true
	pack $frame.sss.check -side left
	pack $frame.sss -side top -fill x -expand true
	frame $frame.qos
	label $frame.qos.label -text "Log out on Save Session State" -anchor w
	checkbutton $frame.qos.check -variable ::PREFS(LOGOUTONSAVE)
	pack $frame.qos.label -side left -fill x -expand true
	pack $frame.qos.check -side top
	pack $frame.qos -side top -fill x -expand true
	center .prefs
}
proc load {} {
	notify "Loading Preferences"
	catch {source [::File::get tkturfrc]}
	option add "*font" $::PREFS(FONT)
}
}
namespace eval Passwd {
proc check {data} {
	if [regexp "Ok" $data] {
		destroy .pass
		return
	}
	if [regexp "Wrong password" $data] {
		tk_dialog .error "Wrong Password" "You entered an incorrect old password." error 0 Okay
		wm deiconify .pass
	}
}
proc change {} {
	if [string compare [.pass.mid.new1 get] [.pass.bot.con get]] {
		tk_dialog .error Error "New password entries do not match" error 0 Oops
		return
	}
	catch {puts $::tprime "c15 hpass password [.pass.top.old get] [.pass.mid.new1 get]"}
	::Capture::addID pass ::Passwd::check
	wm withdraw .pass
}
proc window {} {
	destroy .pass
	toplevel .pass
	wm title .pass "Change Password"
	frame .pass.top
	frame .pass.mid
	frame .pass.bot
	frame .pass.but
	label .pass.top.ld -anchor w -text "Old Password"
	entry .pass.top.old -show *
	label .pass.mid.ew1 -anchor w -text "New Password"
	entry .pass.mid.new1 -show *
	label .pass.bot.on -anchor w -text "Confirm Password"
	entry .pass.bot.con -show *
	button .pass.but.change -text Change -command Passwd::change
	button .pass.but.can -text Cancel -command {destroy .pass}
	pack .pass.top.ld -side left -fill x -expand true
	pack .pass.top.old -side left
	pack .pass.top -side top -fill x
	pack .pass.mid.ew1 -side left -fill x -expand true
	pack .pass.mid.new1 -side left
	pack .pass.mid -side top -fill x
	pack .pass.bot.on -side left -fill x -expand true
	pack .pass.bot.con -side left
	pack .pass.bot -side top -fill x
	pack .pass.but.can -side right
	pack .pass.but.change -side right
	pack .pass.but -side top -fill x
	center .pass
	focus .pass.top.old
	bind .pass <Escape> {destroy .pass}
	bind .pass.top.old <Return> {focus [tk_focusNext %W]}
	bind .pass.mid.new1 <Return> {focus [tk_focusNext %W]}
	bind .pass.bot.con <Return> Passwd::change
}
}
proc NoteSend {wid} {
	global tprime
	if [catch { puts $tprime \n }] { tk_dialog .nomail Error "You can not send a note without being connected" error 0 "Oh Yeah..."; return }
	if {[string length [$wid.top.toent get]] == 0} {
		tk_dialog .error Error "Would you like to specify who this should be mailed to?" error 0 "Yes"
		return
	}
	if {[string length [$wid.bot.subent get]] == 0} {
		tk_dialog .error Error "You must specify a subject" error 0 "Ooops"
		return
	}
	puts $tprime "c15 h[new] note edit"
	puts $tprime ".wipe"
	set message [$wid.text.text get 0.0 end]
	foreach of [lreplace [split $message \n] end end] {
		if ![string length $of] {set of {  }}
		puts $tprime $of
		after 250
	}
	puts $tprime ".end"
	puts -nonewline $tprime "note to "
	puts $tprime [$wid.top.toent get]
	puts -nonewline $tprime "note subject "
	puts $tprime [$wid.bot.subent get]
	puts $tprime "note post"
	destroy $wid
	::Biff::reqnotes
}
proc pine {} {
	global winc
	incr winc
	toplevel .$winc
	wm title .$winc "Note Editor"
	frame .$winc.top
	frame .$winc.bot
	label .$winc.top.to -text "Note to:" -anchor w -width 8
	entry .$winc.top.toent
	pack .$winc.top.to -side left
	label .$winc.bot.sub -text "Subject:" -anchor w -width 8
	entry .$winc.bot.subent
	pack .$winc.bot.sub -side left
	pack .$winc.bot.subent -side left -fill x -expand true
	pack .$winc.top -side top -fill x
	pack .$winc.top.toent -side left -fill x -expand true
	pack .$winc.bot -side top -fill x -expand true
	ScrolledTextWidget .$winc.text -width 60 -height 20 -wrap word
	pack .$winc.text -side top -fill both -expand true
	frame .$winc.buts
	button .$winc.buts.send -text Send -command "NoteSend .$winc"
	button .$winc.buts.cancel -text Cancel -command "destroy .$winc"
	pack .$winc.buts.cancel -side right
	pack .$winc.buts.send -side right
	pack .$winc.buts -side top -fill x
	wm resizable .$winc 0 0
	bind .$winc.top.toent <Return> {focus [tk_focusNext %W]}
	bind .$winc.bot.subent <Return> {focus [tk_focusNext %W]}
	bind .$winc <Escape> "destroy .$winc"
	bind .$winc <Control-Key-x> "NoteSend .$winc"
	focus .$winc.top.toent
	return .$winc
}
proc TabGrep {} {
	global history
	global histind
	set x [expr $histind -1]
	set its 0
	set cstring [.promptline.mainent get]
	set cstring [makereg $cstring]
	if {$::PREFS(CASETAB)} {set flag "--"} {set flag "-nocase"}
	for {} {[regexp $flag ^$cstring $history($x)] != 1} {incr its} {
		incr x -1
		if {($its == $::PREFS(TABLIMIT)) || ($x == -1)} {
			return
		}
	}
	.promptline.mainent delete 0 end
	.promptline.mainent insert 0 $history($x)
}
proc SendMove {x} {
	catch {puts $::tprime "c15 bf[expr $x / 51]"}
}
proc InitCfour {} {
	global cfmap
	set stepx 0
	set stepy 0
	toplevel .cfourwin -takefocus 0
	canvas .cfourwin.board -width 350 -height 350 -background $::COLOURS(CFBG) -takefocus 0
	frame .cfourwin.m
	label .cfourwin.m.message -text "Connect Four" -anchor w -takefocus 0
	pack .cfourwin.board
	pack .cfourwin.m.message -side right -fill x -expand true
	pack .cfourwin.m -side top -fill x -expand true
	for {set a 0} {$a <= 6} {incr a} {
		for {set b 0; set stepy 0} {$b <= 6} {incr b} {
			set cfmap($a,$b) [.cfourwin.board create oval $stepx $stepy [expr $stepx + 50] [expr $stepy +50] -fill $::COLOURS(CFBLANK) -outline $::COLOURS(CFBG) -width 3]
			incr stepy +50
		}
		incr stepx +50
	}
	bind .cfourwin.board <ButtonRelease> {SendMove %x}
	.cfourwin.board config -cursor target
	wm resizable .cfourwin 0 0
	wm title .cfourwin "Connect Four"
	MakeRelay .cfourwin
	bind .cfourwin <Escape> {break}
	bind .cfourwin <Key-F1> {faq C4}
}
proc SendChal {} {
	global tprime
	if [catch {set sel [.plist.listing.list get [.plist.listing.list curselection]]}] {
		tk_dialog .error "Error" "You really should select a player before you try to challenge anyone" error 0 Ooops
		return
	}
	destroy .plist
	catch {puts -nonewline $tprime "c15 bb"}
	catch {puts $tprime $sel}
}
namespace eval Init {
proc session {} {
	global tprime
	global VERSION
	global tcl_platform
	puts $tprime {c15 hdud page 2000}
	puts $tprime "c15 aTkTurf $VERSION ($tcl_platform(os) $tcl_platform(osVersion) ($tcl_platform(machine)))"
	puts $tprime "c15 d"
	puts $tprime "c15 e"
	global histind
	set histind 0
	::Menu::activate .menubar.turf
	::Menu::activate .menubar.games
	.menubar.win entryconfigure "Turf Colour Editor" -state normal
}
proc connect {} {
	catch {after cancel {catch {ConnectDie}}}
	set ::CP 0
	set ::TRIGOFF 0
}
}
proc cfhandle {command} {
	global CP
	global DOT
	global FIRST
	if {$FIRST == 1} {Event::call LOGIN; set FIRST 0}
	regsub "\x1f" $command {} command
	catch {wintalk .scan.text.text $command {}}
	if {[regexp "^bf" $command] == 1} {
		global cfmap
		regsub "^bf" $command {} command
		set x [string index $command 0]
		set y [string index $command 1]
		set fc [string index $command 2]
		set y [expr 6 - $y]
		catch {.cfourwin.board itemconfig $cfmap($DOT(x),$DOT(y)) -stipple "" -outline $::COLOURS(CFBG)}
		set DOT(x) $x
		set DOT(y) $y
		if {$fc == 1} {
			if {$::PREFS(RING) == 1} {
				catch {.cfourwin.board itemconfig $cfmap($x,$y) -fill $::COLOURS(CFRED) -outline $::COLOURS(CFOUT)}
			} {
				catch {.cfourwin.board itemconfig $cfmap($x,$y) -fill $::COLOURS(CFRED)}
			}
			if {$::PREFS(STIPPLE) == 1} {
				catch {.cfourwin.board itemconfig $cfmap($x,$y) -stipple gray50}
			}
		} {
			if {$fc == 2} {
				if {$::PREFS(RING) == 1} {
					catch {.cfourwin.board itemconfig $cfmap($x,$y) -fill $::COLOURS(CFYELLOW) -outline $::COLOURS(CFOUT)}
				} {
					catch {.cfourwin.board itemconfig $cfmap($x,$y) -fill $::COLOURS(CFYELLOW)}
				}
				if {$::PREFS(STIPPLE) == 1} {
					catch {.cfourwin.board itemconfig $cfmap($x,$y) -stipple gray50}
				}
			}
		}
		::Sound::event CFMOVE
		return 0
	}
	if {[regexp "^bc" $command] == 1} {
		destroy .cfourwin
		InitCfour
		return 0
	}
	if {[regexp "^bg" $command] == 1} {
		regsub "^bg" $command {} command
		catch {.cfourwin.m.message config -text $command}
		return 0
	}
	if {[regexp "^ba" $command] == 1} {
		destroy .plist
		toplevel .plist
		wm title .plist "C4 Player Listing"
		ScrolledListWidget .plist.listing -selectmode single 
		focus .plist.listing.list
		bind .plist.listing.list <Double-1> SendChal
		bind .plist.listing.list <Return> SendChal
		pack .plist.listing -side top -fill both -expand true
		frame .plist.holder
		button .plist.holder.ok -text "Challenge" -command SendChal
		button .plist.holder.cancel -text Cancel -command {destroy .plist}
		pack .plist.holder.cancel -side right
		pack .plist.holder.ok -side right
		pack .plist.holder -side bottom -fill x
		bind .plist <Escape> {destroy .plist}
		center .plist
		return 0
	}
	if {[regexp "^bb" $command] == 1} {
		regsub "^bb" $command {} command
		regsub "\n" $command {} command
		catch {.plist.listing.list insert end $command}
		return 0
	}
	if {[regexp "^bd" $command] == 1} {
		if {$CP == 1} {return}
		regsub "^bd" $command {} command
		regsub "\n" $command {} command
		destroy .chal
		global tprime
		toplevel .chal
		wm title .chal "Connect 4 challenge from $command"
		label .chal.from -text "Connect 4 challenge from $command"
		frame .chal.buts
		button .chal.buts.ok -text Accept -command "ChalAcc $command"
		button .chal.buts.no -text Deny -command "destroy .chal; puts $tprime \"c15 c$command C4.denied\""
		pack .chal.from -side top
		pack .chal.buts -side top -fill x
		pack .chal.buts.ok -side left
		pack .chal.buts.no -side left
		bind .chal <Escape> {destroy .chal}
		MakeRelay .chal
		center .chal
		::Sound::event CHAL
		return 0
	}
	if {[regexp "^bh...." $command] == 1} {	
		regsub "^bh" $command {} command
		set x1 [string index $command 0]
		set y1 [string index $command 1]
		set x2 [string index $command 2]
		set y2 [string index $command 3]
		set y1 [expr 6 - $y1]
		set y2 [expr 6 - $y2]
		set x1 [expr $x1 * 50 + 25]
		set x2 [expr $x2 * 50 + 25]
		set y1 [expr $y1 * 50 + 25]
		set y2 [expr $y2 * 50 + 25]
		.cfourwin.board create line $x1 $y1 $x2 $y2 -capstyle round
		bind .cfourwin <Button> {destroy .cfourwin}
		return 0
	}
	EPhandler $command
	return 0
}
proc ChalAcc {name} {
	global tprime
	destroy .chal
	catch { puts -nonewline $tprime "c15 bc"}
	catch { puts $tprime $name }
}
proc EntScroll {direction} {
	global sind
	global history
	global histind
	if {$sind == $histind} {
		set history($sind) [.promptline.mainent get]
	}
	.promptline.mainent delete 0 end
	if {$direction == 1} {
		incr sind -1
		if [catch {.promptline.mainent insert 0 $history($sind)}] {
			set sind 0
			catch {.promptline.mainent insert 0 $history($sind)}
		}
		return
	}
	if {$direction == 0} {
		incr sind
		if [catch {.promptline.mainent insert 0 $history($sind)}] {
				set sind $histind
			catch {.promptline.mainent insert 0 $history($sind)}
		}
		return
	}
}
proc makereg {badstring} {
	regsub -all "\\\\" $badstring \\\\\\ badstring
	regsub -all "\\\|" $badstring \\\| badstring
	regsub -all "\\\[" $badstring \\\[ badstring
	regsub -all "\\\]" $badstring \\\] badstring
	regsub -all "\\\(" $badstring \\\( badstring
	regsub -all "\\\)" $badstring \\\) badstring
	regsub -all "\\\$" $badstring \\\$ badstring
	regsub -all "\\\^" $badstring \\\^ badstring
	regsub -all "\\\*" $badstring \\\* badstring
	regsub -all "\\\+" $badstring \\\+ badstring
	regsub -all "\\\?" $badstring \\\? badstring
	return $badstring
}
proc wintalk {wid tex flags} {
	catch {puts -nonewline $::FILE $tex}
	if {[lindex [$wid yview] 1] == 1} {set s 1} {set s 0}
	$wid config -state normal
	set tex [list $tex]
	set backup $tex
	foreach of $::FILTERS {
		if [catch {$of $wid $tex} tex] {
			tk_dialog .error Error "A critical error has occured.  TkTurf has attempted to recover from it, however results may be erratic.  Please record and report the following error info to the correct person:\n$::errorInfo" error 0 Bugger
		set tex $backup
		break
		}
	}
	set text [lindex $tex end]
	set tex [lreplace $tex end end]
	set tex [lsort -integer -index 0 $tex]
	set lop 0
	foreach of $tex {
		$wid insert end [string range $text $lop [expr [lindex $of 0] - 1]] $flags
		set lop [lindex $of 0]
		if {[lindex $of 1] == 0} {
			set nuke [lsearch $flags [lindex $of 2]]
			if {$nuke > -1} {
				set flags [lreplace $flags $nuke $nuke]
			}
		} {
			lappend flags [lindex $of 2]
		}
	}
	$wid insert end [string range $text $lop end] $flags
	$wid config -state disabled
	if {$s == 1} {$wid see end}
	if {$::DONOTIFY == 1} {::Sound::event NEWTEXT;NotifyUser}
}
proc TTC {win} {
	if {$::tcl_platform(platform) == "windows"} {
		$win tag config sel -background $::COLOURS(SELECT)
		$win tag config find -background $::COLOURS(SELECT) -borderwidth 3 -relief raised
	}
	$win tag config blue -foreground $::COLOURS(BLUE)
	$win tag config red -foreground $::COLOURS(RED)
	$win tag config magenta -foreground $::COLOURS(MAGENTA)
	$win tag config green -foreground $::COLOURS(GREEN)
	$win tag config yellow -foreground $::COLOURS(YELLOW)
	$win tag config cyan -foreground $::COLOURS(CYAN)
	$win tag config white -foreground $::COLOURS(WHITE)
	$win tag config 30 -foreground $::COLOURS(BLACK)
	$win tag config 34 -foreground $::COLOURS(BLUE)
	$win tag config 31 -foreground $::COLOURS(RED)
	$win tag config 35 -foreground $::COLOURS(MAGENTA)
	$win tag config 32 -foreground $::COLOURS(GREEN)
	$win tag config 33 -foreground $::COLOURS(YELLOW)
	$win tag config 36 -foreground $::COLOURS(CYAN)
	$win tag config 37 -foreground $::COLOURS(WHITE)
	$win tag config black -foreground $::COLOURS(BLACK)
	$win tag config bold -font "$::PREFS(FONT) bold"
	$win tag config italic -font "-slant italic"
}
proc ScrolledTextWidget {frame args}  {
	frame $frame
	eval {text $frame.text -yscrollcommand "$frame.yscroll set"} $args
	scrollbar $frame.yscroll -orient vertical -command "$frame.text yview" -takefocus 0 -width $::PREFS(SWIDTH)
	grid $frame.text $frame.yscroll -sticky news
	grid rowconfigure $frame 0 -weight 1
	grid columnconfigure $frame 0 -weight 1
	TTC $frame.text
	bind $frame.text <Control-Key-c> {Copy}
	if {$::tcl_platform(platform) != "windows"} {
		bind $frame.text <Control-Key-v> {Paste %W; break}
	}
	bind $frame.text <Next> {%W yview scroll 1 pages}
	bind $frame.text <Prior> {%W yview scroll -1 pages}
	return $frame.text
}
proc LogOut {} {
	catch {Prompt::show "Quitting"}
	::Sound::event DISCONNECT
	if [catch {puts $::tprime "quit"}] {set ::CNECT 0; ConnectDie}
	after 7000 {catch {ConnectDie}}
}
proc GrabListing {} {
	set ::CP 0
	catch {puts $::tprime "c15 ba"}
}
proc MainInterFace {} {
	wm title . "TkTurf $::VERSION"
	wm protocol . WM_DELETE_WINDOW {quit}
	if {$::PREFS(MENU) == 1} {
		. config -menu .menubar
	}
	menu .menubar -tearoff 0
	menu .menubar.connection
	menu .menubar.edit
	menu .menubar.games
	menu .menubar.turf
	menu .menubar.opts
	menu .menubar.win
	menu .menubar.help
	menu .menubar.help.amuse
	.menubar add cascade -label Connection -underline 0 -menu .menubar.connection
	.menubar.connection add command -label Connect -underline 0 -command GetSock -state disabled
	.menubar.connection add command -label Disconnect -underline 0 -command LogOut
	.menubar.connection add separator
	.menubar.connection add command -label "Statistics" -underline 0 -command StatusWin
	.menubar.connection add command -label "Log Dump" -underline 0 -command LDump
	.menubar.connection add command -label "Lock (Ctrl-L)" -underline 5 -command {LT 1}
	.menubar.connection add separator
	.menubar.connection add command -label "Quit (Ctrl-Q)" -underline 0 -command {catch {close $FILE}; LogOut; set QUIT 1; if {$CNECT == 0} {exit}}
	.menubar add cascade -label Edit -underline 0 -menu .menubar.edit
	.menubar.edit add command -label "Copy (Ctrl-c)" -command {Copy}
	.menubar.edit add command -label "Paste (Ctrl-v)" -command {Paste .promptline.mainent}
	.menubar.edit add command -label "Find (Ctrl-f)" -command Find::window
	.menubar.edit add command -label "Find Again (Ctrl-g)" -command Find::search
	.menubar.edit add separator
	.menubar.edit add command -label "Alias Editor" -command Alias::window
	.menubar.edit add command -label "Autologin Editor" -command ::Login::window
	.menubar.edit add command -label "Trigger Editor" -command ::Triggers::window
	.menubar add cascade -label Amusements -underline 0 -menu .menubar.games
	.menubar.games add command -label "Connect Four" -underline 8 -command "GrabListing" -state disabled
	.menubar.games add command -label "Chess" -underline 0 -command "ChessFindPlayers" -state disabled
	.menubar.games add command -label Reversi -command {RListP} -state disabled
	.menubar.games add command -label Battleship -command BattleFindPlayers -state disabled
	.menubar add cascade -label Turf -underline 0 -menu .menubar.turf
	.menubar.turf add command -label "Note edit" -underline 0 -command pine -state disabled
	.menubar.turf add command -label "Change Password" -underline 7 -command Passwd::window -state disabled
	.menubar.turf add command -label "Room Editor"	-underline 0 -command RoomEdit::window -state disabled
	.menubar.turf add command -label "Description Editor" -underline 0 -command DEW -state disabled
	.menubar add cascade -label Options -underline 0 -menu .menubar.opts
	.menubar.opts add check -label "Triggers Off" -variable TRIGOFF
	.menubar.opts add check -label "Ignore Games" -variable CP
	.menubar.opts add check -label "Filter Flashing" -variable ::PREFS(FILTER)
	.menubar.opts add check -label "New Text Notify" -variable ::PREFS(NOTIFY)
	.menubar.opts add command -label "(Un)Hide Entry (Ctrl-h)" -command swaphide
	.menubar add cascade -label Window -underline 0 -menu .menubar.win
	.menubar.win add command -label "Preferences" -underline 0 -command Preferences::window
	.menubar.win add command -label "Turf Colour Editor" -command Colour::window -state disabled
	.menubar.win add command -label "Colour Configurator" -underline 0 -command CCW
	.menubar.win add command -label "Amusements Colours" -command GCCW
	.menubar.win add command -label "Clear Window" -underline 6 -command ClearWindows
	.menubar.win add separator
	.menubar.win add command -label "Check TkTurf Version" -command ConfirmVersion
	.menubar.win add separator
	menu .menubar.help.f
	.menubar.help add command -label "About TkTurf" -command AboutTkTurf
	.menubar.help add command -label Changelog -command {faq CHANGELOG}
	.menubar.help add command -label Features -command {faq FEAT}
	menu .menubar.help.v
	.menubar.help add cascade -menu .menubar.help.v -label "Display"
	.menubar.help.v add command -label "Message Filtering" -command {faq FLT}
	.menubar.help add cascade -label Amusements -menu .menubar.help.amuse
	.menubar.help.amuse add command -label "Connect Four" -command {faq C4}
	.menubar.help.amuse add command -label Chess -command {faq CHELP}
	.menubar.help.amuse add command -label Reversi -command {faq REVERH}
	.menubar.help.amuse add command -label Battleship -command {faq BSHELP}
	menu .menubar.help.a
	.menubar.help add cascade -menu .menubar.help.a -label "Advanced"
	.menubar.help.a add command -label "Command Stringing" -command {faq MCS}
	.menubar.help.v add command -label Prompts -command {faq PRMPTS}
	.menubar.help.v add command -label "Boss Key" -command {faq BOSSKEY}
	.menubar.help.a add command -label Aliases -command {faq ALS}
	.menubar.help.a add command -label "Triggers" -command {faq TRI}
	.menubar.help.a add command -label "Output Piping" -command {faq CMDPIPE}
	menu .menubar.help.plugins
	.menubar.help add cascade -label Plugins -menu .menubar.help.plugins
	.menubar.help.plugins add command -label "Installed Plugins" -command PluginInfo
	.menubar.help.plugins add command -label "Plugin Help" -command {faq PLGS}
	menu .menubar.help.misc
	.menubar.help add cascade -menu .menubar.help.misc -label "Misc"
	.menubar.help add command -label Errata -command {faq ERR}
	.menubar add cascade -label Help -underline 0 -menu .menubar.help
	.menubar.help.misc add command -label Logging -command {faq LOGGER}
	frame .promptline
	entry .promptline.mainent -takefocus 1
	label .promptline.prompt -text "" -takefocus 0 -anchor w -pady 0 -padx 0
	frame .promptline.tray
	pack .promptline.tray -side right
	pack .promptline.mainent -side right -fill x -expand true
	pack .promptline.prompt -side right
	pack .promptline -side bottom -fill x
	bind .promptline.mainent <Return> {STDre .promptline.mainent}
	ScrolledTextWidget .filter -width 80 -height $::PREFS(FILTERSIZE) -wrap word -state normal -relief flat -cursor "" -background $::COLOURS(BG) -foreground $::COLOURS(BLACK) -takefocus 0
	.filter.text config -state disabled
	if {$::PREFS(FILTER) == 1} {pack .filter -side bottom -fill both}
	ScrolledTextWidget .twid -width 80 -height 25 -wrap word -state normal -relief flat -cursor "" -background $::COLOURS(BG) -foreground $::COLOURS(BLACK) -takefocus 0
	pack .twid -side bottom -fill both -expand true
	catch {.twid.text image create 0.0 -image $::TURFLOGO}
	bind . <Up> {EntScroll 1}
	bind . <Down> {EntScroll 0}
	if [string compare $::tcl_platform(platform) "unix"] {
		bind . <FocusIn> {catch {focus -force .promptline.mainent}}
		bind .twid.text <Key> {break}
		bind .twid.text <Button> {.twid.text config -state normal}
		bind .twid.text <ButtonRelease> {.twid.text config -state disabled; catch {focus -force .promptline.mainent}}
	}
	bind all <Control-Key-p> {EntScroll 1}
	bind all <Control-Key-n> {EntScroll 0}
	bind all <Control-Key-u> {.promptline.mainent delete 0 end}
	bind all <Control-Key-q> {quit}
	bind all <Control-Key-d> {ctrld %W}
	bind all <Control-Key-l> {LT 1}
	bind all <Control-Key-s> {LT 0}
	bind all <Control-Key-c> {Copy; break}
	bind . <Control-Key-f> {Find::window}
	bind . <Control-Key-g> {Find::search}
	bind all <Meta-Key-p> {EntScroll 1}
	bind all <Meta-Key-n> {EntScroll 0}
	bind all <Meta-Key-u> {.promptline.mainent delete 0 end}
	bind all <Meta-Key-q> {quit}
	bind all <Meta-Key-l> {LT 1}
	bind all <Meta-Key-c> {Copy}
	bind . <Meta-Key-f> {Find::window}
	bind . <Meta-Key-g> {Find::search}
	bind .promptline.mainent <Tab> {catch {TabGrep}; break}
	.twid.text config -state disabled
	wm protocol . KWM_SAVE_YOURSELF {System::saveSessionState}
	wm protocol . WM_SAVE_YOURSELF {System::saveSessionState}
	bind .promptline.mainent <Shift-Return> {.promptline.mainent insert insert "\n\r"; break}
	bind .promptline.mainent <Meta-Return> {CommandHandle [.promptline.mainent get]}
	bind .promptline.mainent <Control-Return> {CommandHandle [.promptline.mainent get]}
	bind . <FocusIn> {SetDoNotify VisibilityUnobscured}
	bind . <FocusOut> {SetDoNotify VisibilityFullyObscured}
	bind . <Next> {.twid.text yview scroll 1 pages}
	bind . <Prior> {.twid.text yview scroll -1 pages}
	bind . <Shift-Next> {.filter.text yview scroll 1 pages; break}
	bind . <Shift-Prior> {.filter.text yview scroll -1 pages; break}
	bind . <Control-Next> {.twid.text see end}
	bind . <Control-Prior> {.twid.text see 0.0}
	bind . <Control-Shift-Next> {.filter.text see end}
	bind . <Control-Shift-Prior> {.filter.text see 0.0}
	bind .promptline.mainent <Meta-Left> {.promptline.mainent icursor 0}
	bind .promptline.mainent <Meta-Right> {.promptline.mainent icursor end}
	bind . <Button-3> {catch {tk_popup .menubar [winfo pointerx .] [winfo pointery .]; focus -force .menubar}}
	bind . <Shift-Button-3> {break}
	bind . <Control-Button-3> {break}
	bind . <Control-Shift-Button-3> {break}
	bind . <Control-Button> {tk_popup .menubar [winfo pointerx .] [winfo pointery .]; focus -force .menubar}
	bind .promptline.mainent <Button-2> {break}
	bind . <Button-2> {Paste .promptline.mainent; break}
	bind .promptline.mainent <ButtonRelease-2> {Paste .promptline.mainent;break}
	bind all <Control-Key-h> {swaphide;break}
	bind all <Control-Key-z> ::Boss::here
	bind all <Control-Key-Z> ::Boss::here
	bind all <FocusIn> {SetDoNotify VisibilityUnobscured}
	bind all <FocusOut> {SetDoNotify VisibilityFullyObscured}
	bind .twid.text <Visibility> {set VIS %s; SetDoNotify %s}
	bind . <Unmap> {set VIS VisibilityFullyObscured; SetDoNotify VisibilityFullyObscured}
	if {$::BROWSER} {
		if {$::tcl_platform(platform) != "windows"} {
			center .
		}
	} {wm geometry . 650x350+0+0}
	if {$::tcl_platform(platform) == "windows"} {
		focus -force .promptline.mainent
	}
	focus -force .promptline.mainent
}
proc GetSock {} {
	global tprime
	global ptog
	global STAT
	global RX
	set RX 0
	notify "Connecting. This may take a moment."
	set ptog 0
	.promptline.mainent config -show {}
	if [catch {socket $::PREFS(SSHHOST) $::PREFS(SSHPORT)} tprime] {
		if {([string length $::PREFS(PROXY)] > 0) && ([string length $::PREFS(SSHHOST)] > 0)} {
			notify "Falling back to PROXY"
			after 1000
		}
		set proxinit "c turf.org 4000\n"
		if $::PREFS(SOCKS) {
			set proxinit [binary format "ccScccca*c" 4 1 4000 206 165 33 252 sockspray 0]
		}
		if [catch {socket $::PREFS(PROXY) $::PREFS(PROXYPORT)} tprime] {
			if {[string length $::PREFS(PROXY)] > 0} {
				notify "Falling back to DIRECT"
				after 1000
			}
			set proxinit ""
			if [catch {socket turf.org 4000} tprime] {
				destroy .ad
				::Sound::event CNECTERR
				ConnectErrorWin
				catch {
				.menubar.connection entryconfigure Connect -state normal
				.menubar.connection entryconfigure Disconnect -state disabled}
				return
			}
		}
		puts -nonewline $tprime "$proxinit"
		flush $tprime
	}
	::Sound::event CONNECT
	Event::call CONNECT
	set STAT Connected
	fconfigure $tprime -buffersize 1 -buffering none -blocking 0 -translation binary
	fileevent $tprime readable ReadMain
	.menubar.connection entryconfigure Connect -state disabled
	.menubar.connection entryconfigure Disconnect -state normal
	puts $tprime "ClientConnect\n\377\375\031" nonewline
	global CNECT
	set CNECT 1
	if {$::PREFS(LOGIN) == 1} {::Login::loginwin}
	ClearWindows
	.twid.text see end
}
proc ConnectDie {} {
	Event::call DISCONNECT
	set ::histind -6
	set ::sind 0
	catch {unset ::history}
	.history.panel.list delete 0 end
	catch {Prompt::show ""}
	catch {close $::tprime}
	set ::STAT Disconnected
	.menubar.connection entryconfigure Connect -state normal
	.menubar.connection entryconfigure Disconnect -state disabled
	.menubar.win entryconfigure "Turf Colour Editor" -state disabled
	set ::FIRST 1
	wm title . "TkTurf $::VERSION"
	set ::NAME ""
	Menu::deactivate .menubar.turf
	Menu::deactivate .menubar.games
	if {$::QUIT == 1} {exit}
}
proc ReadMain {} {
	global tprime
	global rbuf
	global appbuf
	global ptog
	global READING
	if {$READING} {
		update idletasks
		return
	}
	set READING 1
	if [eof $tprime] {
		.twid.text config -state normal
		catch {.twid.text image create end -image $::TURFLOGO}
		.twid.text see end
		.twid.text config -state disabled
		catch {Prompt::show "Disconnected"}
		ConnectDie
		set ::CNECT 0
		set READING 0
		return
	}
	set toline [read $tprime]
	set ::RX [expr $::RX + [string length $toline]]
	append appbuf "$toline"
	regsub -all "\n" $appbuf {} appbuf
	regsub -all "\r" $appbuf \n appbuf
	regexp ".*(ÿ)*(Press RETURN to continue:)*(\[Please type c, r, b, h, q, or RETURN\]:)*(\n)*(\377û)*" $appbuf tem1
	append rbuf $tem1
	set hd [regsub -all "\x01" $rbuf {} rbuf]
	if {$hd == 1} {
		if {$ptog == 0} {
			.promptline.mainent config -show *
			set ptog 1
		} { .promptline.mainent config -show {}
			set ptog 0
		}
	}
	regsub ".*(By what name do you wish to be known\?)*(Press RETURN to continue:)*(\[Please type c, r, b, h, q, or RETURN\]:)*(\n)*(\377û)*" $appbuf {} appbuf
	regsub ".*\n" $rbuf {} prompt
	regsub -all "ÿü" $prompt {} prompt
	if [regsub {ÿ.*} $prompt {} prompt] {
		regsub -all "\\\\n" $prompt "\n" promptpro
		regsub -all "ÿ." $promptpro {} promptpro
		if {$promptpro != ""} {catch {Prompt::show $promptpro}}
	}
	regsub -all "\[^\n\]*ÿ(ù|ï)" $rbuf  rbuf
	regsub -all "\n\[^\n\]*ÿ(ù|ï)" $rbuf \n rbuf
	regsub -all "\[^\n\]*ÿ(ù|ï)" $rbuf {} rbuf
	if [regsub -all "\a" $rbuf {} rbuf] ::Sound::bell
	regsub -all -- "ÿ." $rbuf {} rbuf
	regsub "<!-\b\b\b\x19" $rbuf {} rbuf
	while {[regexp "\[^\n\]*\n+" $rbuf match] == 1} {
		display $match
		regsub "\[^\n\]*\n+" $rbuf {} rbuf
	}
	set READING 0
}
proc display {line} {
	global WINDOW
	global tflags
	global triggers
	for {set c [regexp "^\[\x1f\]" $line]} {$c} {set c [regexp "^\[\x1f\]" $line]} {
		set cfcom {}
		regexp "^\[\x1f\]\[^\n\]*\n" $line cfcom
		regsub "^\[\x1f\]\[^\n\]*\n+" $line {} line
		catch {cfhandle $cfcom} val
		return
	}
	if {$::CMD_ID != {}} {
		regexp "(\[^\x1f\]*)\n+" $line match
		regsub "(\[^\x1f\]*)\n+" $line {} line
		if {$match == {}} {return}
		Capture::process $match
	}
	regsub -all "\x1f" $line {} line
	if {[regexp ".*\n" $line trigbuf] == 1 && $::TRIGOFF == 0} {
		foreach string [split $trigbuf \n] {
			regsub -all "\[\x1b\]\[^m\]*m" $string {} string
			foreach of [array names triggers] {
				if [regexp -- $of $string match 1 2 3 4 5 6 7 8 9] {
					catch {eval $triggers($of)}
				}
			}
		}
	}
	for {set g [string first \x1b $line]} {$g != -1} {set g [string first \x1b $line]} {
		if {$g > 0} {
			set tempout [string range $line 0 [expr $g -1]]
			wintalk $WINDOW $tempout $tflags
			set line [string trimleft $line $tempout]
			if {$WINDOW == ".filter.text"} {regsub \n $line {} line; wintalk $WINDOW \n $tflags}
			continue
		}
		if {$g == 0} {
			if {[string first m $line] < 1} {break}
			regsub "\x1b" $line {} line
			set tempout [string first m $line]
			set tempout [string range $line 0 $tempout]
			set tem1pout [makereg $tempout]
			regsub -- $tem1pout $line {} line
			if {[regexp \\\[1 $tempout] == 1} {
				lappend tflags "bold"
			}
			if {[regexp \\\[5 $tempout] == 1} {
				if {$::PREFS(FILTER) == 1} {set WINDOW .filter.text}
				if {$::PREFS(ITALIC)} {lappend tflags "italic"}
			}
			if {[regexp \\\[0 $tempout] == 1} {
				set tflags {}
				set WINDOW .twid.text
			}
			if {[regexp \\\[m $tempout] == 1} {
				set tflags {}
				set WINDOW .twid.text
			}
			regexp "(\[0-9\]\[0-9\])m" $tempout match good
			catch {append tflags " $good"}
			set good {}
		}
	}
	if [regexp "(.*\n)" $line temp1 temp] {
		wintalk $WINDOW $temp $tflags
	}
}
proc STDre {widg} {
	global tprime
	global history
	global histind
	global sind
	global MULTI
	set oline [$widg get]
	$widg delete 0 end
	if {([regexp "^ *$" $oline ] != 1) && ($histind != -6)} {
		if {$histind == 0 || ($oline != $history([expr $histind - 1]))} { 
			set history($histind) $oline
			incr histind
			.history.panel.list insert end $oline
			.history.panel.list see end
		}
		set sind $histind
	}
	if ![string length $oline] {puts $tprime {}; return}
	set oline [split $oline "\n\r"]
	foreach of $oline {
		foreach filter $::CMDFILTERS {
			set of [$filter $of]
		}
		foreach al $::Aliases::names {
			set lkey [makereg $al]
			if {[regexp "^ *${lkey}( |$)" $of] == 1} {
				regsub "^ *$lkey" $of {} of
				if [catch {eval ::Aliases::$al $of}] {
					global errorInfo
					tk_dialog .error "Alias Execution Error" "$errorInfo" error 0 Okay
				}
				set of {}
			}
		}
		if [regexp "^ *finger" $of] {
			regsub "^ *finger *" $of {} of
			finger $of
			continue
		}
		if [regexp "^ *multi" $of] {
			regsub "^ *multi" $of {} MULTI
			if [string length $MULTI] {
				wintalk .twid.text "Entering multi mode.\nType ! to exit multi.\n" {}
			} {
				wintalk .twid.text "Multi what?\n" {}
			}
			append MULTI " "
			continue
		}
		if [regexp "^ *!" $of] {
			if [string length $MULTI] {
				set MULTI {}
				wintalk .twid.text "Exiting multi mode.\n" {}
				continue
			}
		}
                if [regsub "^/(.+)" $of {\1} of] {
                        catch {puts $tprime $of}
                } else {
		        catch {puts $tprime "$MULTI$of"}
                }
	}
}
Preferences::setdefaults
Preferences::setcoldefaults
Preferences::loadcolours
Preferences::load
Login::load
Triggers::load
Alias::load
Plugins::load
::Sound::event START
if {$PREFS(LOG) == 1} {
	if {$tcl_platform(platform) == "unix"} {
		set fname [file join $env(HOME) ".tkturf/logs/[exec date]"]
		regsub -all " " $fname _ fname
		catch {set FILE [open $fname w]}
	} {
		catch {::File::open turflog a} FILE
	}
	catch {unset fname}
}
notify "Loading KDE colours"
catch {KDE::Loadcolours}
notify "Loading theme"
catch {option readfile [file join $BASEDIR "theme"]}
catch {option readfile [::File::get theme]}
if {$PREFS(CKV) == 2} {
	wm deiconify .
	set ::PREFS(CKV) [tk_dialog .question "Version Check" "TkTurf can automatically check your TkTurf version.  Decide if you would like it to do so and select the choice below.  If you have a proxy select NO and turn this option on after setting your proxy." questhead 1 "Don't Check" Check]
	::Preferences::save
	wm withdraw .
}
if {$PREFS(CKV) == 0} {
	notify "Version Check OFF"
	after 750
} 
if {$PREFS(CKV) == 1} {
	catch {ConfirmVersion}
}
notify "Main Interface"
MainInterFace
wm deiconify .
toplevel .boss
wm overrideredirect .boss 1
wm geometry .boss 3x3+0+0
button .boss.bg -command ::Boss::gone
pack .boss.bg
.boss config -cursor hand2
wm withdraw .boss
notify "Loading Help Texts"
set CHANGELOG {Changelog:

	
3.4
	Added button wrapping to the ButtonNotebook widget
	Bug fix in the status window
	Minor Biff improvements
	Chess piece correction
	Finger code improved
	Bad plugins will now have a hard time causing an actual TkTurf crash
3.3
	Thanks to Mango for the output filter protocol idea
	Added marker-based output filtering system, yet another extension for
		plugin compatability
	Thanks to Mango for the gzipping ideas
	Added transparent Gzip (un)compression of almost all touched files for
		UNIX systems only (configurable on/off & level)
	Added optional use of gzexe on tkturf for UNIX systems
	Biff reply function is independent of the Turf note reply function, and
		is more flexable about note subject and who the reply will be
		sent to (defaults to all recipients, as does Turf)
	Harder to flood the socket when sending large notes
	Harder to flood the socket when sending large room descriptions
	Removed listing number of bytes sent... with all the new stuff it was
		(very) incorrect anyway
	Reduced the number of meaningless Capture:: warnings printed
	Improved ::register command
	Better config +blank support
	API extended to support identification of prompt plugin demarcators
	More bug fixes to keep Biff from getting confused
	Plugin Registry repaired on reloading
	Added HTTP automatic-upgrade error checking
	Added note forwarding to Biff
	Fixed bugs in the newer Plugin Info window
	Added Italics preference saving (oops)
	Added version checking to the register API function
3.2
	Improved Plugin Info window to include scrolling and made it more
		obvious that clicking on a name provides a brief description
	Improvements to Biff to keep it from getting confused about number of
		new notes (when posted and then deleted)
	Extended cooperative plugin system to include command entry filters
	Exec command piping uses Spool::enqueue to avoid socket flooding
		(thanks to Karzan for finding that glitch)
	Preferences now save on log-out
	Added Mango's emacs-backup patch
	Added possible use of italics
	Fade number checking added
	Windows workaround for hex numbers in Fade::getShade
3.11
	Bugfixes in the new cooperative plugins code
3.1
	Added Mango's cooperative plugins idea
	Fixed TkTurf Locking bug with popup windows
	Better protection from dodgy Prompt plugins
	Added Fade namespace with getShade function for colour shading
	Pager-bug workaround
	Added Prompt namespace and prompt display changes to allow easy
		prompt modifications by plugins
	Coverted Biff to the new plugin API rather than manual overrides
}
set FEAT {TkTurf Features:
	
MUD-play Features 
       Triggers - with full TCL scripting reactions, including sound 
       Aliases - with full TCL scripting
       New message notification
       Infinite scrollback buffer
       Scrollable command history
       Configurale length tab recent command completion 
       Client-side multi-mode 
       Colour (configurable - allowing non-ANSI colours) 
       Filtering of special text to a special window 
       Auto-logins 
       Command stringing 
       Logging 
       Screen dumping 
       Command output piping 
       Input shading 
       Boss key 
Games 
       Client-Server-Client Games 
              Connect Four 
       Client-Client Games 
              Chess 
              Reversi 
              Battleship 
       Configurable game colours 
       F1-key help on all games 
Sound 
       Sound support 
       Sound playing based on events 
       Sound playing based on triggers 
Network 
       Built-in global finger (finger whoever@wherever.com) 
       Automatic version checking and upgrading 
       Proxy support 
       Datapipe support 
       SOCKS proxy support 
       HTTP proxy support (for version upgrading) 
Front-Ends 
       Note system - with extended features
		Note-forwarding
		Customizable note replying
       Colour setup
       Room editor
       Description editor
Client 
       Plugin system 
       Many available plugins 
       Fully configurable, right down to scrollbar width 
       Fully graphical configuration 
       X11 session management
}
set BIFFFAQ {Biff Help:
	Biff provides a graphical note interface to reading, new note creation, deletion, and the reply facility.  To activate the interface, either click the mail icon in the lower right of the main TkTurf screen, or selection Turf->Note Manager from the menus.
	To read a note, either double click on it, or click once on it and click the read button.
	To delete a note, either double-click with the right mouse button on it, double click the left button whilst holding control, or click once on it and use the delete button.
	To reply to a note, either select it and use the reply button, or select it and hit ctrl-r.
	You may read/reply/delete more than one note at once.  To select more than one you may either drag the selection using the left mouse button, or select notes one at a time using control-click.  You must then use the button for the associated action, as double clicking will cause the selection to be replaced by the single item you double click on.  Control-r will also work for multiple note reply.
	
	Control-x may be used as a shortcut to send the reply. Biff may be optionally set to pop up the note management window whenever new mail arrives.  This preference defaults to yes and can be set through the preferences window.
}
set LOGGER {Logging:
	
TkTurf autologging automatically logs any text displayed in any window's text
area.  Logs in UNIX are stored in ~/.tkturf/logs/ by timestamp.  Logs under
Windows and MacOS are stored in /tkturf/turflog, as an append-based log.
}
set FLT {Message Filtering:
	
TkTurf allows you to filter certain types of information to a smaller, special
window.  To activate this feature go to the preferences window and activate
message filtering.  You may alter the use of this feature quickly, but not
permanently by using the Options menu and the Filter Flashing check box.
	
Next you have to select what sorts of messages you wish to filter to this
special window.  This is done by using the colconfig command on Turf. First
off you must have colour turned on (config +colour).  Then set the message
types you wish to have filtered to flashing <anycolour>, example:
	
	colconfig 7 flashing blue
	
This would set your personal tells to be filtered to the special window, which
might be useful if you happen to be running through rooms or in combat, to
ensure that you do not miss out on anything.
	
Key Bindings:
	Shift-PGUP : up one page
	Shift-PGDN : down one page
}
set C4 {Connect Four:
	
The object of connect four is to stack pieces so that you get for of your
pieces in a row (diagonal, horizontal, or vertical) before your opponent
does.  Click in any column to place your piece.}
set CHELP {Chess:
	
To move a chess piece click on it, and then click on the destination you would
like the piece to arrive at. The background behind a selected piece will
change colours to set it apart.
	
To castle in chess, select the king piece and click on the space right next to
the king's rook.
	
Game Help:
	
	Pawns: move one space forward (optionally two on the first move only).
		Attack on forward diagonals.  Pawns who reach the far row
		become queens.
	
	Rooks/Castles: move/attack any number of spaces vertically or
		horizontally.
	
	Knights: move/attack in L-patterns, one up/down, two right/left; or one
		right/left and two up/down.
	
	Bishops: move/attack any number of diagonal spaces.
	
	King: move/attack one in any direction.  Unmoved kings may castle to an
		unmoved rook.
	
	Queen: move/attack any number of spaces in any direction
}
set REVERH {Reversi:
	
The object of reversi is to have more of the pieces on the board be yours at
the end than the number than belongs to your opponent. To move you must "jump"
over one or more of your opponents pieces. You can not jump across blanks.
	
Strategy Help:
	
Since the object of the game is to end with more pieces than your opponent has
it is important to capture those spaces which can not be easily re-taken. 
Such spaces include the edges, and the corners.  It is important to carefully
consider what is to be gained before giving up a single corner.  This is
especially important if that corner can serve as a jumping point to the next
corner over.
	
The are two most common general strategies are: never giving up any edges, and
strategically giving up edges.  The first strategy is more likely to provide a
novice with luck, since it is fairly easy to take edges with brute force.  The
second strategy relies on the skill in setting up the other player in such a
manner that they are forced later in the game to surrender the whole board. 
This is the strategy of masters, and is quite difficult for novices.}
set BSHELP {Battleship:
	
To place pieces in Battleship use the left mouse button and drag them to the
desired area. Pieces will automatically snap to fit the grid.  To flip a piece
from vertical to horizontal or vice-versa, use the right mouse button, or
ctrl-click with the left mouse button on the piece you wish to flip.}
set TRI {Triggers v2.0
	
The triggers dialog gives you a listing of all existing triggers and the
option to create a new trigger, change an existing one, or delete the
highlighted trigger.  Note that editing an existing trigger and changing the
search string will create a clone of the trigger with the new search (if you
want to get rid of the old one you must delete it).  This is so that similar
triggers may be cloned easily.
	
TkTurf uses Perl and TCL/TK style regular expressions with nine substring match
buffers.  Here is a brief (and comprehensible) explanation of what you can do
with triggers and what the basics of regular expressions are.
Regular expression syntax defines the following special characters:
	
	][$^?+*()|\.
	
If you wish to use any of those as a literal symbol, you must "escape it" by
doing this "\?" which would mean a real question mark, or "\." which would
mean a real period.  If you want a real "\", you have to put "\\".
	
These special symbols let you do neat things with triggers, here is a summary
of what each special symbol means:
	
[] can be used to delimit a set of characters, for example [a-z] would match
any lower-case letter, and [a-z0-9] would match any lower case letter or
number. To use these they must be escaped UNLESS they are in parenthesis (i.e.
\[^ \] unless it is ([^ ])
	
^ can be combined with [] to say anything which does NOT match the pattern, for
example [^0-9] would match anything which was NOT a number, and [^ ] would
match anything which is not a space, and so on. It can also be used to bind a
trigger to the start of a line, for example "^You disappear" would match "You
disappear into the void." but not "Fastjack says 'You disappear.'"
	
$ can be used to bind text to the end of a line, such as "You disappear into
the void\.$" which would match "You disappear into the void." but not
"Fastjack says 'You disappear into the void.'"
	
? means zero or one of the previous character, for example, g? would mean zero
or one letter g's
	
* means zero or more of the previous character, y* would mean zero or any other
number of y's.  This is most useful with something such as [^ ]* which would
mean all characters which were not spaces (i.e. any one word)
	
() can be used to delimit a sub pattern, sub patterns will be saved into
buffers named 1-9, in the order in which the () sets appear.  For example
"([^ ]) throws a snowball at you\." would mean save whatever word is at the
start of that sentence and put it in buffer 1.  More on this later.
	
| can be used inside of () to say or, so (you|me) would match "you" or "me". 
You may have as many of these as you like inside a () set.
	
\ indicates an escape character, such as \[\], or any other escaped symbol such
as a literal  $ would be \$
	
Okay, now what can you do with all this garbage?  Here are some handy examples,
the trigger is on top, the reply action on the bottom:
	
	([^ ]*) throws a snowball at you\.
	send "snowball $1"
	
This trigger means *save the first word in the line* in buffer one, the reply
uses the saved word in buffer one to snowball the original thrower.  The
buffers can be used in this manner, by putting $1 or $2, $3, etc wherever you
want the information from any buffer.
	
You could also filter bombs...
	([^ ]*) gives you (a|an) (armed grenade|bomb|stick of dynamite)
	send "drop $3"
	send "glare $1"
	
This would scan for people giving you an armed grenade, or a bomb, or a stick
of dynamite and automatically drop it, and glare at the giver, by using buffers
1 and 3, as they are named from left to right.}
set ERR {TkTurf Errata:
	All:
		Having config +blank on will cause some client based features
			to feed blank lines into the window. This can not be
			fixed, as it relates to how Turf handles blanks and the
			client protocol.
}
set PRMPTS {To use multi-line prompts:
	
TkTurf goes over Turf's head to give you multi-line prompts to use this
feature just add a "\n" into your prompt configure command.  For example, this
would give you a two line prompt with your hit points on one row, and the room
name you are currently in in another:
	
	prompt %h/%H\n%R
	
This would be a three line showing hp and room on third line:
		
	prompt %h/%H\n\n%R
	
Regrettably, it is impossible for TkTurf to use the multi-line prompts which
Turf provides.  Using them will result in part of the prompt appearing in the
main text window.}
set ALS {Aliases:
	
Aliases are a way of shortening commands, such as "c 'cure light' who" which
are not exactly easy to type quickly during combat, or combining multiple
commands into one, such as making an alias named "junk" which will drop an
item and then sacrifice it.
	
Aliases in TkTurf are fully scripted in TCL, using the TkTurf API to help.
Help with scripting issues is available from the alias editor window.
	
As an example of creating an alias with an argument, such as a "junk" command
(a command to drop and sacrifice an item), you would enter the alias name as
"junk", and then, in the command body, you would type 'send "drop $1"' on the
first line, and then 'send "sac $1"' on the second.  To call this alias you
would just type "junk boot" and the alias would handle the rest.  Arguments in
aliases are named $1-$9, respective of their positions.  So, in an alias typed
as rescue sneezy sleepy dopey, $1 would be sneezy, $2 would be sleepy, and $3
would be dopey.}
set CMDPIPE {Command Piping:
	
Enter "exec <command to execute>" and hold down meta (unix only) or control
(windows and UNIX) and hit return (while HOLDING control or meta).
	
Since command output is not generally in Turf command format it is useful to
use the Turf multi feature to do something constructive with this output. For
example, to chat a list of UNIX processes running:
		
	multi chat <Return>
	exec ps ax <Control-Return>*
		
*Note - an immortal will promptly warn you if you echo your entire process
list to chat...}
set MCS {To send multiple commands at once:
	
Let's say you want to go to Mtf's position, steal his gold, and go home before
he starts to toast you.  You could try to do it by typing the commands
normally, or, with tkturf you can type the following:
	
	goto mtf<press shift-return>steal coins from mtf<press
	shift-return>home<press return>*
	
When you finally press return without holding shift it will send all three
commands at once, and Turf will execute them instantly rather than having to
wait for you to type each one.
	
*Note: Mtf does not like having his gold stolen, especially sums of over 40
Million...}
set PLGS {Plugins:
	
The TkTurf plugin system allows anyone to distribute code patches which are
not part of the "official" distribution.  To use a plugin simply download it
and place it in C:\tkturf\plugins\ in Windows, or in a folder called
tkturf/plugins right inside the hard drive icon on a Mac, or in UNIX place
them in ~/.tkturf/plugins/.
	
TkTurf also allows system-wide plugins to be placed in the plugins directory,
which should be a subdirectory of whatever directory TkTurf is stored in (i.e.
/usr/local/tkturf/plugins)}
set DBG {Debugging Help:
	
WARNING:  READ THIS THOROUGHLY
	
It is often helpful in debugging for Nog to be able to execute commands
in your running copy of TkTurf. Most likely Nog will just want to see an
internal variable, but the command could be anything.  Debugging commands
can reveal your site information, control your Turf session, or even cause
damage to your computer.  Allowing debugging is done AT YOUR OWN RISK, and
it is recommended that, should you consider allowing this, you choose the
'warn' option, discussed below, to preview commands as they come.
	
The first time each session that Nog wants to use this feature it will query
you with three choices: accept, refuse, and warn. Accept means that you will
always accept debugging commands, refuse means you are refusing the request,
and warn means that each time Nog sends a debug command you will be shown the
command and asked if you would like to allow that specific command in that
specific instance.
	
At any time you may change the permission for debugging by using the
Connection->Statistics menu option.
	
The debugging feature is only available to Nog.
}
set BOSSKEY {The Boss/Librarian Key:
	
The boss key (ctrl-z) is a key which will make all of the TkTurf windows
disappear entirely.  To restore TkTurf click on the upper leftmost corner of
the screen (you might notice a 2x2 pixel box there, which is the target of
your click).  When the mouse is over the target the cursor should change to a
hand.  This will restore all the windows just as they were.
	
This feature may not work on some systems.  2.811+ features a newer
implementation.  Bosskey is now faster on hide and restore, hides all
non-iconified windows, and should work on all systems/window managers.} 
set SOUND {TkTurf Sounds:
	
TkTurf does not possess an inate ability to play sounds, and must therefore
depend on external command-line based programs to play sounds. The sound
preference specifies this player.  If you are using Windows, a suitable
command line player may be found at http://www.turf.org/tkturf/sound.exe.
Thanks to Ali for creating this program.
	
To set the sound player, go to Window->Preferences and select the Sound
button, then click in the blank box, which will pop up a file dialog for you
to select the appropriate file with.
	
Sounds are not available on Macintosh.}
set TCODE {TkTurf Action Scripting:
	
TkTurf uses TCL scripting for aliases and triggers, which allows tremendous
power and flexability, but does make it less easy to use. However, it is still
easy enough to use for simple actions.
	
To add text to send to Turf use the send command in quotes, like so:
	send "say Hello"
	
This would send "say Hello" to Turf.  Certain symbols must be preceeded by a
backslash, or they will not come out right (like this: \$), because these
symbols have special significance in the TCL language. Here is the list:
${}[]"';\
	
To add a sound to play, merely click the "Insert Sound" button. This will give
you a file dialog, which you simply select the sound to play with.
	
Advanced Use:
	
TkTurf allows any valid TCL statements, and provides nine possible
preconfigured variables ($1-$9) with text saved from the action (the parts of
the triggers in parenthesis, saved in order: see triggers help; or, in the case
of aliases, text provided after the alias as an argument).

Triggers also provide the variable $match, for the whole match, and aliases
provide $args for all the whole list of arguments.
	
The TkTurf API includes two function calls for ease of use, send {} and
::Sound::play {}, which send text to Turf and play a sound, respectively.}
Plugins::install
Menu::deactivate .menubar.turf
Menu::deactivate .menubar.games
Alias::makelist
Event::on CONNECT Init::connect
Event::on LOGIN Init::session
GetSock
destroy .ad
trace variable ::PREFS(FILTER) w filterflick
puts {Please note that any error output past this point is an advisory warning, not
a problem.  Please do not report this output unless aberrant behaviour is noted
in conjuction with warnings.
}
#EOF