bind pub - pong pub_ping


proc pub_ping {nick uhost hand chan arg} {
  putchan $chan "ping"
}


set logbuche(1) "logbuecher/logbuch1.txt"
set logbuche(2) "logbuecher/logbuch2.txt"
set logbuche(3) "logbuecher/logbuch3.txt"
set logbuche(4) "logbuecher/logbuch4.txt"
set logbuche(5) "logbuecher/logbuch5.txt"
set logbuche(6) "logbuecher/logbuch6.txt"
set logbuche(7) "logbuecher/logbuch7.txt"
set logbuche(8) "logbuecher/logbuch8.txt"
set logbuche(9) "logbuecher/logbuch9.txt"
set logbuche(10) "logbuecher/logbuch10.txt"
set logbuche(11) "logbuecher/logbuch11.txt"

set logbuchc(1) "logbuecher/logbuchc1.txt"
set logbuchc(2) "logbuecher/logbuchc2.txt"
set logbuchc(3) "logbuecher/logbuchc3.txt"
set logbuchc(4) "logbuecher/logbuchc4.txt"
set logbuchc(5) "logbuecher/logbuchc5.txt"
set logbuchc(6) "logbuecher/logbuchc6.txt"
set logbuchc(7) "logbuecher/logbuchc7.txt"
set logbuchc(8) "logbuecher/logbuchc8.txt"
set logbuchc(9) "logbuecher/logbuchc9.txt"
set logbuchc(10) "logbuecher/logbuchc10.txt"
set logbuchc(11) "logbuecher/logbuchc11.txt"

proc flug_schreiber {zaehler text} {
global logbuchc
set fd [open $logbuchc($zaehler) r]
while {![eof $fd]} {
set tmp [gets $fd]
          if {[eof $fd]} {break}
}
     close $fd
     set fd [open $logbuchc($zaehler) a]
     puts $fd "$text"
     putlog "$text"
     flush $fd
     close $fd
}


set kontrolle 1

bind ctcp - "ACTION" action_proc 
bind msg n rpgstart msg_startrpg
bind msg n reichweite msg_reichweite
bind msg n transporterreichweite msg_transporterreichweite
bind msg n waffenreichweite msg_waffenreichweite
bind msg - beam msg_beam
bind msg - impulse msg_impulse
bind msg - warp msg_warp
bind msg n beenden msg_beenden
bind msg - pt msg_ptfeuer
bind msg - qt msg_qtfeuer
bind msg - ph msg_phfeuer
bind msg - com msg_com
bind msg - scan msg_scan
bind msg - schilde msg_schilde
bind msg - waffen msg_waffen
bind msg - tarnung msg_tarnung
bind msg - energie msg_engergie
bind msg - computerlogbuch msg_computerlogbuch
bind msg - end msg_endcom
bind msg - antworten msg_antwort
bind msg n personal msg_personal
bind pub n !kontrolle pub_kontrolle
bind pub n !rpgstat pub_rpgstats
bind pub n !setvariable pub_variablen
bind pub n !energie pub_energie1
bind pub n !schilde pub_schilde1
bind pub n !qtzahl pub_qtzahl1
bind pub n !qtrampen pub_qtrampen1
bind pub n !ptzahl pub_ptzahl1
bind pub n !ptrampen pub_ptrampen1
bind pub n !co pub_co1
bind pub n !conn pub_conn1
bind pub n !tac pub_tac1
bind pub n !fo pub_fo2
bind pub n !med pub_med1
bind pub n !cou pub_cou1
bind pub n !chi pub_chi1
bind pub n !personal pub_personal
bind pub n var pub_var



proc pub_personal {nick uhost hand chan arg} {
  global co conn tac chi cou med fo
  set number [lindex $arg 0]
  set who [lindex $arg 1]
  set co($number) $who
  putchan $chan "CO : $co($number)"
  set conn($number) $who
  putchan $chan "CONN : $conn($number)"
  set fo($number) $who
  putchan $chan "FO : $fo($number)"
  set tac($number) $who
  putchan $chan "TAC : $tac($number)"
  set chi($number) $who
  putchan $chan "CHI : $chi($number)"
  set cou($number) $who
  putchan $chan "COU : $cou($number)"
  set med($number) $who
  putchan $chan "MED : $med($number)"
}


proc pub_var {nick uhost hand chan arg} {
  global treichweite reichweite
  set eins [lindex $arg 0]
  set zwei [lindex $arg 1]
  set drei [lindex $arg 2]
  set text "$eins)($zwei"
  set treichweite($text) $drei
  set text "$zwei)($eins"
  set treichweite($text) $drei
}



proc msg_personal {nick uhost hand arg} {
  global tac co conn rpgmaster schiff schiffszahl
  set zaehler 0
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    putlog "$zaehler:"
    putlog "$schiff($zaehler)"
    putlog "tac: $tac($zaehler)"
    putlog "co: $co($zaehler)"
    putlog "conn: $conn($zaehler)"
  }
}



proc pub_kontrolle {nick uhost hand chan arg} {
  global wreichweite schiffszahl reichweite schiff
  set zaehler 0
  set schiffe " "
  set schiffe [nick_convert $schiffe]
  set test ""
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    set test $schiffe
    set schiffe "$test|[nick_convert $schiff($zaehler)]"
    putlog "t"
  }
  putchan $chan "$schiffe"
  putlog "$schiffe"
  set zaehler 0
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    set zaehler2 0
    set text ""
    set test "[nick_convert $schiff($zaehler)]"
    while {$zaehler2 < $schiffszahl} {
      set zaehler2 [expr $zaehler2 + 1]
      set telt "$zaehler)($zaehler2"
      putlog "$zaehler $zaehler2"
      set text "$test"
      set test "$text|     $reichweite($telt)    "
    }
    putlog "$test"
    putchan $chan "$test"
  }
  set zaehler 0
  set schiffe " "
  set schiffe [nick_convert $schiffe]
  set test ""
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    set test $schiffe
    set schiffe "$test|[nick_convert $schiff($zaehler)]"
  }
  putchan $chan " "
  putchan $chan "$schiffe"
  putlog "$schiffe"
  set zaehler 0
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    set zaehler2 0
    set text ""
    set test "[nick_convert $schiff($zaehler)]"
    while {$zaehler2 < $schiffszahl} {
      set zaehler2 [expr $zaehler2 + 1]
      set telt "$zaehler)($zaehler2"
      set text "$test"
      set test "$text|     $wreichweite($telt)    "
    }
    putlog "$test"
    putchan $chan "$test"
  }
}



proc nick_convert {nick} {
  set return "$nick"
  set 1 [string index $nick 0]
  set 2 [string index $nick 1]
  set 3 [string index $nick 2]
  set 4 [string index $nick 3]
set 5 [string index $nick 4]
set 6 [string index $nick 5]
set 7 [string index $nick 6]
set 8 [string index $nick 7]
set 9 [string index $nick 8]
set 10 [string index $nick 10]
if {$1 == ""} {
set reutrn "     $nick     "
return $return
}
if {$2 == ""} {
set return "    $nick     "
return $return
}
if {$3 == ""} {
set return "    $nick    "
return $return
}
if {$4 == ""} {
set return "   $nick    "
return $return
}
if {$5 == ""} {
set return "   $nick   "
return $return
}
if {$6 == ""} {
set return "  $nick   "
return $return
}
if {$7 == ""} {
set return "  $nick  "
return $return
}
if {$8 == ""} {
set return " $nick  "
return $return
}
if {$9 == ""} {
set return " $nick "
return $return
}
if {$10 == ""} {
set return "$nick "
return $return
}
return $return
}



proc msg_energie {nick uhost hand arg} {
global chi schilde energie reichweite schiff tac
set energie [lindex $arg 0]
if {$nick == $chi(1)} {
if {$energie > energie(1)} {
putserv "PRIVMSG $nick :Es ist nur noch $energie(1) Energie verfuegbar"
return 0
}
set energie(1) [expr $energie(1) - $energie]
set schilde1 [expr $schilde(1) + energie / 2]
putserv "PRIVMSG $nick :Hauptenergie: $energie(1) / Schildenergie: $schilde(1)"
if {$reichweite == 1} {
putserv "PRIVMSG $tac(2) :$schiff(1) hat nun $energie(1) energie, $schilde(1) Schildenergie ($energie uebertragen)"
}
}
if {$nick == $chi(2)} {
if {$energie > energie(2)} {
putserv "PRIVMSG $nick :Es ist nur noch $energie2 Energie verfuegbar"
return 0
}
set energie2 [expr $energie2 - $energie]
set schilde2 [expr $schilde2 + $energie / 2]
putserv "PRIVMSG $nick :Hauptenergie: $energie2 / Schildenergie: $schilde2"
if {$reichweite == 1} {
putserv "PRIVMSG $tac2 :$schiff(1) hat nun $energie2 energie, $schilde2 Schildenergie ($energie uebertragen)"
}
}
}


proc msg_tarnung {nick uhost hand arg} {
  global schilde waffen tarnvorrichtung tarn tac schiff reichweite rpgmaster schiffszahl
  set zaehler 0
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    if {$nick == $tac($zaehler)} {
      if {$tarnvorrichtung($zaehler) == 0} {
        putserv "privmsg $nick :$schiff($zaehler) hat keine tarnvorrichtung!"
        putserv "PRIVMSG $rpgmaster :$schiff($zaehler) tarnt.. keine tarnvorrichtung"
        return 0
      }
      set befehl [lindex $arg 0]
      if {$befehl == "aktivieren"} {
        if {$tarn($zaehler) == 1} {
	  putserv "privmsg $nick :Die Tarnung ist bereits aktiv!"
	  putserv "PRIVMSG $rpgmaster :$schiff($zaehler) tarnt.. bereits aktiv"
	  return 0
	}
	if {$schilde($zaehler) == 1} {
	  putserv "privmsg $nick :Um sich Tarnen zu koennen, muessen schilde und Waffen deaktiviert sein"
	  return 0
	}
	if {$waffen($zaehler) == 1} {
	  putserv "privmsg $nick :Um sich tarnen zu koennen, muessen schilde und Waffen deaktiviert sein"
	  return 0
	}
	set tarn($zaehler) 1
	putserv "privmsg $nick :Die Tarnung wurde erfolgreich aktiviert"
	putserv "PRIVMSG $rpgmaster :$schiff($zaehler) tarnt sich"
	set zaehler2 0
	while {$zaehler2 < $schiffszahl} {
	  set zaehler2 [expr $zaehler2 + 1]
	  set text "$zaehler)($zaehler2"
	  if {$reichweite($text) == 1} {
	    putserv "privmsg $tac($zaehler2) :Das Schiff tarnt sich"
	  }
        }
      }
      if {$befehl == "deaktivieren"} {
        if {$tarn($zaehler) == 0} {
	  putserv "privmsg $nick :Die Tarnung ist bereits deaktiviert!"
	  return 0
        }
        set tarn($zaehler) 0
        putserv "privmsg $nick :Die Tarnung wurde erfolgreich deaktiviert"
        putserv "PRIVMSG $rpgmaster :$schiff($zaehler) deaktiviert die tarnung"
        set zaehler2 0
        while {$zaehler2 < $schiffszahl} {
	  set zaehler2 [expr $zaehler2 + 1]
	  set text "$zaehler)($zaehler2"
	  if {$reichweite($text) == 1} {
	    putserv "privmsg $tac($zaehler2) :Ein schiff enttarnt sich"
          }
        }
      }
    }
  }
}

proc pub_fo1 {a b c d e} {
  global fo1
  set nick [lindex $e 0]
  set fo1 $nick
}

proc pub_fo2 {a b c d e} {
global fo
set nick [lindex $e 1]
set fo([lindex $e 0]) $nick
}
proc pub_med1 {a b c d e} {
global med1
set nick [lindex $e 0]
set med1 $nick
}
proc pub_med2 {a b c d e} {
global med2
set nick [lindex $e 0]
set med2 $nick
}
proc pub_cou1 {a b c d e} {
global cou1
set nick [lindex $e 0]
set cou1 $nick
}
proc pub_cou2 {a b c d e} {
global cou2
set nick [lindex $e 0]
set cou2 $nick
}
proc pub_chi1 {a b c d e} {
global chi1
set nick [lindex $e 0]
set chi1 $nick
}
proc pub_chi2 {a b c d e} {
global chi2
set nick [lindex $e 0]
set chi2 $nick
}


proc msg_computerlogbuch {nick uhost hand arg} {
  global co schiffszahl fo logbuche
  set zaehler 0
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    if {$nick == $co($zaehler) || $nick == $fo($zaehler)} {
      set fd [open $logbuche($zaehler) r]
      while {![eof $fd]} {
        set tmp [gets $fd]
        if {[eof $fd]} {break}
      }
      close $fd
      set fd [open $logbuche($zaehler) a]
      puts $fd "$arg"
      putlog "$arg"
      flush $fd
      close $fd
    }
  }
}

proc msg_waffen {nick uhost hand arg} {
  putlog "vor global"
  global tac reichweite schiff tarn schiffszahl
  putlog "nach global"
  set zaehler 0
  putlog "1. whileschleife"
  while {$zaehler < $schiffszahl} {
    putlog "in der 1. schleife."
    set zaehler [expr $zaehler + 1]
    putlog "$zaehler"
    if {$nick == $tac($zaehler)} {
      if {$tarn($zaehler) == 1} {
        putserv "PRIVMSG $nick :Das Schiff ist getarnt, und kann daher nicht die Waffensysteme aktivieren."
        return 0
      }
      set stat [lindex $arg 0]
      if {$stat == "aktivieren"} {
        global waffen
        set waffen($zaehler) 1
        putserv "PRIVMSG $tac($zaehler) :Waffen wurden aktiviert"
        set zaehler2 0
        putlog "$zaehler2 < $schiffszahl"
        flug_schreiber $zaehler "Die Waffen werden aktiviert."
        while {$zaehler2 < $schiffszahl} {
          putlog "while - schleife"
          set zaehler2 [expr $zaehler2 + 1]
          set text "$zaehler)($zaehler2"
          if {$reichweite($text) == 1} {
            putserv "PRIVMSG $tac($zaehler2) :$schiff($zaehler) aktiviert die Waffen"
            flug_schreiber $zaehler2 "$schiff($zaehler) aktiviert die Waffen"
          }
        }
      }
      if {$stat == "deaktivieren"} {
        global waffen
        set waffen($zaehler) 0
        putserv "PRIVMSG $tac($zaehler) :Waffen wurden deaktiviert"
        set zaehler2 0
        flug_schreiber $zaehler "Die Waffen werden deaktiviert"
        while {$zaehler2 < $schiffszahl} {
          putlog "2. whileschleife"
          set zaehler2 [expr $zaehler2 + 1]
          set text "$zaehler)($zaehler2"
          if {$reichweite($text) == 1} {
            putserv "PRIVMSG $tac($zaehler2) :$schiff($zaehler) deaktiviert die Waffen"
            flug_schreiber $zaehler2 "$schiff($zaehler2) deaktiviert die Waffen"
          }
        }
      }
    }
  }
}

proc action_proc {nick uhost hand chan keyword text} {
  global tac co conn chi cou fo med
  set command [lindex $text 0]
  putlog "$command"
  if {[string index $chan 0] != "#"} { return 0 }
  if {$nick != "Vadm_Poul"} { 
    if {$chan == "#ufp"} { return 0 }
  }
  putlog "$command"
  set command [lindex $text 0]
  set ziel [lindex $text end]
  if {[onchan $ziel $chan] == 0} { return 0 }
  putlog "$command"
  if {$command == "feuert"} {
    set ziel [lindex $text end]
    set treffer [rand 10]
    putlog "$treffer"
    if {$treffer < 4} {
      putchan $chan "$nick hat $ziel nicht getroffen"
    } else {
      if {$treffer < 8} {
        putchan $chan "$nick schiesst einen betaeubenden Schuss auf $ziel ab"
        putserv "MODE $chan -v $ziel"
        posten_uebernahme $ziel $chan
      } else {
        if {$treffer < 9} {
          putchan $chan "$nick schiesst einen toetlichen Schuss auf $ziel ab"
          putserv "KICK $chan $ziel"
          posten_uebernahme $ziel $chan
        }
      }
    }
  }
  putlog "$command"
  if {$command == "behandelt"} {
    set zielv [lindex $text 1]
    set posten [lindex $text 2]
    if {$nick != $med1} {
      if {$nick != $med2} { return 0 }
    }
    if {[onchan $ziel $chan] == 0} { return 0 }
    putlog "Wiederbelebung ($zielv / $posten)"
    utimer 30 "wiederbelebung $zielv $posten $chan"
  }
}

proc wiederbelebung {ziel posten chan} {
  global co1 co2 tac1 tac2 conn1 conn2 chi1 chi2 cou1 cou2 fo1 fo2 channel1
  if {$chan == $channel1} {
    if {$posten == "co"} {
      putchan $chan "$ziel ist ab sofort CO"
      putserv "MODE $chan +v $ziel"
      set co1 $ziel
    }
    if {$posten == "tac"} {
      putchan $chan "$ziel ist ab sofort Tac/Sec"
      putserv "MODE $chan +v $ziel"
      set tac1 $ziel
    }
    if {$posten == "conn"} {
      putchan $chan "$ziel ist ab sofort CONN"
      putserv "MODE $chan +v $ziel"
      set conn1 $ziel
    }
    if {$posten == "chi"} {
      putchan $chan "$ziel ist ab sofort CHI"
      putserv "MODE $chan +v $ziel"
      set chi1 $ziel
    }
    if {$posten == "cou"} {
      putchan $chan "$ziel ist ab sofort COU"
      putserv "MODE $chan +v $ziel"
      set cou1 $ziel
    }
    if {$posten == "fo"} {
      putchan $chan "$ziel ist ab sofort FO"
      putserv "MODE $chan +v $ziel"
      set fo1 $ziel
    }
  } else {
    if {$posten == "co"} {
      putchan $chan "$ziel ist ab sofort CO"
      putserv "MODE $chan +v $ziel"
      set co2 $ziel
    }
    if {$posten == "tac"} {
      putchan $chan "$ziel ist ab sofort Tac/Sec"
      putserv "MODE $chan +v $ziel"
      set tac2 $ziel
    }
    if {$posten == "conn"} {
      putchan $chan "$ziel ist ab sofort CONN"
      putserv "MODE $chan +v $ziel"
      set conn2 $ziel
    }
    if {$posten == "chi"} {
      putchan $chan "$ziel ist ab sofort CHI"
      putserv "MODE $chan +v $ziel"
      set chi2 $ziel
    }
    if {$posten == "cou"} {
      putchan $chan "$ziel ist ab sofort COU"
      putserv "MODE $chan +v $ziel"
      set cou2 $ziel
    }
    if {$posten == "fo"} {
      putchan $chan "$ziel ist ab sofort FO"
      putserv "MODE $chan +v $ziel"
      set fo2 $ziel
    }
  }
}


proc posten_uebernahme {ziel chan} {
  global tac1 tac2 co1 co2 fo1 fo2 chi1 chi2 med1 med2 cou1 cou2 conn1 conn2
  if {$ziel == $tac1} {
    set tac1 ""
if {$chi1 != ""} {
putchan $chan "$chi1 uebernimmt ab sofort den Posten des Tac/Sec"
set tac1 $chi1
}
}
if {$ziel == $tac2} {
set tac2 ""
if {$chi2 != ""} {
putchan $chan "$chi2 uebernimmt ab sofort den Posten des Tac/Sec"
set tac2 $chi2
}
}
if {$ziel == $co1} {
set co1 ""
if {$fo1 != ""} {
putchan $chan "$fo1 uebernimmt ab sofort das Kommando"
set co1 $fo1
}
}
if {$ziel == $co2} {
set co2 ""
if {$fo2 != ""} {
putchan $chan "$fo2 uebernimmt ab sofort das Kommando"
set co2 $fo2
}
}
if {$ziel == $conn1} {
set conn1 ""
if {$cou1 != ""} {
putchan $chan "$cou1 uebernimmt ab sofort den Posten des CONN"
set conn1 $cou1
}
}
if {$ziel == $conn2} {
set conn2 ""
if {$cou2 != ""} {
putchan $chan "$cou2 uebernimmt ab sofort den Posten des CONN"
set conn2 $cou2
}
}
}


proc msg_scan {nick uhost hand arg} {
  global schiff treichweite reichweite tac schildstat schilde waffen tarn ptzahl phzahl ptrampen qtzahl qtrampen rpgmaster warpfaktor warp warpziel schiffszahl wreichweite
  set ziel [lindex $arg 0]
  set was [lindex $arg 1]
  if {$ziel == ""} {
    putserv "PRIVMSG $nick :Verwendung: scan <schiff> <zusatz>, oder scan umgebung"
  }
  if {$ziel == "umgebung"} {
    set zaehler 0
    while {$zaehler < $schiffszahl} {
      set zaehler [expr $zaehler + 1]  
      if {$nick == $tac($zaehler)} {
        putserv "PRIVMSG $nick :Folgende Schiffe sind in Scannerreichweite :"
        flug_schreiber $zaehler "Scan der Umgebung:"
        set zaehler2 0
        while {$zaehler2 < $schiffszahl} {
          set zaehler2 [expr $zaehler2 + 1]
          set text "$zaehler)($zaehler2"
          if {$reichweite($text) == 1} {
            if {$tarn($zaehler2) == 0} {
              putserv "PRIVMSG $nick :$schiff($zaehler2)"
              flug_schreiber $zaehler "  $schiff($zaehler2)"
              if {$wreichweite($text) == 1} {
                putserv "PRIVMSG $nick :  ist in Waffenreichweite"
                flug_schreiber $zaehler "    ist in Waffenreichweite"
              } else {
                if {$treichweite($text) == 1} {
                  putserv "PRIVMSG $nick :  ist in Transporterreichweite"
                  flug_schreiber $zaehler "    ist in Transporterreichweite"
                } else {
                  putserv "PRIVMSG $nick :  ist in Scannerreichweite"
                  flug_schreiber $zaehler "    ist in Scannerreichweite"
                }
              }
            }
          }
        }
        putserv "PRIVMSG $nick :Ende der Liste"
        flug_schreiber $zaehler "Ende der Liste"
      }
    }
    return 0
  }
  set zaehler 0
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    putlog "$zaehler"
    putlog "$nick == $tac($zaehler)"
    if {$nick == $tac($zaehler)} {
      putlog "$ziel == $schiff($zaehler)"
      if {$ziel == $schiff($zaehler)} {
        if {$was == "waffen"} {
          putserv "PRIVMSG $nick :Es sind $ptzahl($zaehler) PTs, $ptrampen($zaehler) PTrampen, $qtzahl($zaehler) QTs, $qtrampen($zaehler) QTrampen, $phzahl($zaehler) PHstaerke verfuegbar"
          putserv "PRIVMSG $rpgmaster :$schiff($zaehler) scannt ihre waffen"
          return 0
        }
        if {$was == "warp"} {
          putserv "PRIVMSG $nick :Dieses Schiff kann maximal Warp $warpfaktor($zaehler) fliegen, derzeit fliegt sie mit Warp $warp($zaehler), Ziel: $warpziel($zaehler)"
          putserv "PRIVMSG $rpgmaster :$schiff($zaehler) scannt ihren Warpantrieb"
          return 0
        }
        putserv "PRIVMSG $nick :Bei diesem Schiff handelt es sich um die $schiff($zaehler), [class $schiff($zaehler)] Es hat die Schilde [schilde $schildstat($zaehler)], und die Waffen [schilde $waffen($zaehler)]"
        putserv "PRIVMSG $rpgmaster :$schiff($zaehler) scannt sich"
        return 0
      }
      set zaehler2 0
      while {$zaehler2 < $schiffszahl} {
        set zaehler2 [expr $zaehler2 + 1]
   	putlog "$ziel == $schiff($zaehler2)"
   	putlog "$zaehler2"
   	if {$ziel == $schiff($zaehler2)} {
    	  putlog "$zaehler)($zaehler2"
    	  set text "$zaehler)($zaehler2"
    	  if {$reichweite($text) == 1} {
     	    if {$tarn($zaehler2) == 1} {
      	      putserv "PRIVMSG $nick :Dieses Schiff ist nicht in Scannerreichweite"
      	      putserv "PRIVMSG $rpgmast :$schiff($zaehler) scannt... $schiff($zaehler2) getarnt"
      	      return 0
     	    }
     	    if {$was == "waffen"} {
       	      putserv "PRIVMSG $nick :Es sind $ptzahl($zaehler2) PTs, $ptrampen($zaehler2) PTrampen, $qtzahl($zaehler2) QTs, $qtrampen($zaehler2) QTrampen, $phzahl($zaehler2) PHstaerke verfuegbar"
              putserv "PRIVMSG $tac($zaehler2) :Sie werden gescannt (waffen)"
              putserv "PRIVMSG $rpgmaster :$schiff($zaehler) scannt $schiff($zaehler2) (waffen)"
              return 0
            }
            if {$was == "warp"} {
      	      putserv "PRIVMSG $nick :Dieses Schiff kann maximal Warp $warpfaktor($zaehler2) fliegen, derzeit fliegt sie mit Warp $warp($zaehler2), Ziel: $warpziel($zaehler2)"
      	      putserv "PRIVMSG $tac($zaehler2) :Sie werden gescannt (Warp)"
              putserv "PRIVMSG $rpgmaster :$schiff($zaehler) scannt $schiff($zaehler2) (Warp)"
              return 0
            }
      	    putserv "PRIVMSG $nick :Bei diesem Schiff handelt es sich um die $schiff($zaehler2), [class $schiff($zaehler2)] Es hat die Schilde [schilde $schildstat($zaehler2)], und die Waffen [schilde $waffen($zaehler2)]"
            putserv "PRIVMSG $tac($zaehler2) :Sie werden gescannt"
            putserv "PRIVMSG $rpgmaster :$schiff($zaehler) scannt $schiff($zaehler2)"
            return 0
          } else {
            putserv "PRIVMSG $nick :Dieses Schiff ist nicht in Scannerreichweite"
            return 0
          }
        }
      }
    }
  }
}



proc schilde {schildstat} {
if {$schildstat == 1} {
set stat "aktiviert"
}
if {$schildstat == 0} {
set stat "deaktiviert"
}
return $stat
}


proc class {schiff} {
if {$schiff == "Einstein"} {
  set einsteinclass "ein Schiff der Novell class"
  return $einsteinclass
}
if {$schiff == "Civic"} {
  set civicclass "einen bajoranischer Frachter"
  return $civicclass
}
if {$schiff == "Quark"} {
  set quarkclass "ein Ferengifrachter"
  return $quarkclass
}
if {$schiff == "DS9"} {
  set ds "eine cardassinaische Raumstation"
  return $ds
}
}

proc msg_reichweite {nick uhost hand arg} {
  global channel reichweite tac tarn schiff schiffszahl
  set ausser [lindex $arg 0]
  set schiff1 [lindex $arg 1]
  set schiff2 [lindex $arg 2]
  set tac1 "$tac($schiff1)"
  set tac2 "$tac($schiff2)"
  set tarn1 "$tarn($schiff1)"
  set tarn2 "$tarn($schiff2)"
  if {$ausser == "ausser"} {
    set text "$schiff1)($schiff2"
    if {$reichweite($text) == 0} {
      putserv "privmsg $nick :Die beiden schiffe sind bereits ausser scannerreichweite."
      return 0
    }
    set reichweite($text) 0
    set text "$schiff2)($schiff1"
    set reichweite($text) 0
    if {$tarn1 == 1} {
      if {$tarn2 == 1} { return 0 }
      flug_schreiber $schiff1 "$schiff($schiff2) kommt ausser scannerreichweite"
      putserv "PRIVMSG $tac1 :$schiff($schiff2) ausser scannerreichweite"
      putserv "privmsg $nick :Die schiffe kommen in scannerreichweite, $schiff($schiff1) ist getarnt"
      return 0
    }
    putserv "privmsg $tac1 :$schiff($schiff2) ausser Scannerreichweite"
    putserv "Privmsg $tac2 :$schiff($schiff1) ausser Scannerreichweite"
    putserv "PRIVMSG $nick :Die schiffe sind nun ausser scannerreichweite"
    flug_schreiber $schiff1 "$schiff($schiff2) kommt ausser scannerreichweite"
    flug_schreiber $schiff2 "$schiff($schiff1) kommt ausser scannerreichweite"
    set text "$schiff1)($schiff2"
    set reichweite($text) 0
    set text "$schiff2)($schiff1"
    set reichweite($text) 0
    return 0
  }
  if {$tarn($schiff1) == 1} {
    if {$tarn($schiff2) == 1} { return 0 }
    putserv "PRIVMSG $tac1 :Ein Schiff kommt in scannerreichweite"
    putserv "privmsg $nick :Die schiffe kommen in scannerreichweite, $schiff1 ist getarnt"
    flug_schreiber $schiff1 "Ein Schiff kommt in scannerreichweite"
    set text "$schiff1)($schiff2"
    set reichweite($text) 1
    set text "$schiff2)($schiff1"
    set reichweite($text) 1
    return 0
  }
  if {$tarn($schiff2) == 1} {
    putserv "PRIVMSG $tac2 :Ein Schiff kommt in scannerreichweite"
    putserv "PRIVMSG $nick :Die Schiffe kommen in Scannerreichweite, $schiff2 ist getarnt"
    flug_schreiber $schiff2 "Ein Schiff kommt in Scannerreichweite"
    set text "$schiff1)($schiff2"
    set reichweite($text) 1
    set text "$schiff2)($schiff1"
    set reichweite($text) 1
    return 0
  }
  putserv "privmsg $tac1 :Ein schiff kommt in Scannerreichweite"
  putserv "Privmsg $tac2 :Ein schiff kommt in Scannerreichweite"
  putserv "PRIVMSG $nick :Die schiffe sind nun in scannerreichweite"
  flug_schreiber $schiff2 "ein Schiff kommt in Scannerreichweite"
  flug_schreiber $schiff1 "ein Schiff kommt in Scannerreichweite"
  putlog "$schiff1)($schiff2"
  set text "$schiff1)($schiff2"
  set reichweite($text) 1
  putlog "$schiff2)($schiff1"
  set text "$schiff2)($schiff1"
  set reichweite($text) 1
}

proc msg_transporterreichweite {nick uhost hand arg} {
  global channel treichweite reichweite tac tarn schiff schiffszahl
  set ausser [lindex $arg 0]
  set schiff1 [lindex $arg 1]
  set schiff2 [lindex $arg 2]
  set text "$schiff1)($schiff2"
  putlog "test"
  if {$ausser == "ausser"} {
    putlog "ausser"
    if {$treichweite($text) == 0} {
      putserv "PRIVMSG $nick :Die beiden Schiffe sind nicht in transporterreichweite"
      return 0
    }
    if {$tarn($schiff1) == 1} {
      if {$tarn($schiff2) == 1} {
        putserv "PRIVMSG $nick :Die beiden Schiffe sind nicht nicht mehr in transporterreichweite, beide sind getarnt"
        set treichweite($text) 0
        set text "$schiff2)($schff1"
        set treichweite($text) 0
        return 0
      }
      putserv "PRIVMSG $nick :$schiff($schiff1) $schiff($schif2) ausser transporterreichweite, $schiff($schiff2) ist getarnt"
      putserv "PRIVMSG $tac($schiff1) :$schiff($schiff2) ist nun ausser transporterreichweite"
      flug_schreiber $schiff1 "$schiff($schiff2) ausser transporterreichweite"
      set treichweite($text) 0
      set text "$schiff2)($schiff1"
      set treichweite($text) 0
      return 0
    }
    if {$tarn($schiff2) == 1} {
      putserv "PRIVMSG $nick :$schiff($schiff1) $schiff($schiff2) = getarnt"
      set treichweite($text) 0
      set text "$schiff2)($schiff1"
      set treichweite($text) 0
      putserv "PRIVMSG $tac($schiff2) :$schiff($schiff1) ist nun ausser Transporterreichweite"
      flug_schreiber $schiff2 "$schiff($schiff1) ist nun ausser Transporterreichweite"
      return 0
    }
    putserv "PRIVMSG $nick :$schiff($schiff1) $schiff($schiff2)"
    set treichweite($text) 0
    set text "$schiff2)($schiff1"
    set treichweite($text) 0
    putserv "PRIVMSG $tac($schiff1) :$schiff($schiff2) ist nun ausser Transporterreichweite"
    putserv "PRIVMSG $tac($schiff2) :$schiff($schiff1) ist nun ausser Transporterreichweite"
    flug_schreiber $schiff1 "$schiff($schiff2) ist ausser Transporterreichweite"
    flug_schreiber $schiff2 "$schiff($schiff2) ist ausser Transporterreichweite"
    return 0
  }
  putlog "in"
  if {$reichweite($text) == 0} {
    putlog "nicht in reichweite"
    putserv "PRIVMSG $nick :Die beiden Schiffe sind nicht mal noch in scannerreichweite"
    return 0
  }
  if {$treichweite($text) == 1} {
    putlog "in treichweite"
    putserv "PRIVMSG $nick :Die beiden Schiffe sind bereits in transporterreichweite"
    putlog "nach privmsg"
    return 0
  }
  if {$tarn($schiff1) == 1} {
    putlog "1 = getarnt"
    if {$tarn($schiff2) == 1} {
      putlog "2 = getarnt"
      putserv "PRIVMSG $nick :Die Schiffe kommen in transporterreichweite, beide sind getarnt."
      set treichweite($text) 1
      set text "$schiff2)($schiff1"
      set treichweite($text) 1
      return 0
    }
    putserv "PRIVMSG $nick :$schiff($schiff1) $schiff($schiff2) in transporterreichweite, $schiff($schiff1) ist getarnt"
    set treichweite($text) 1
    set text "$schiff2)($schiff1"
    set treichweite($text) 1
    putserv "PRIVMSG $tac($schiff1) :Ein Schiff kommt in Transporterreichweite"
    flug_schreiber $schiff1 "Ein Schiff kommt in Transporterreichweite"
    return 0
  }
  if {$tarn($schiff2) == 1} {
    putlog "2 = getarnt"
    putserv "PRIVMSG $nick :$schiff($schiff1) $schiff($schiff2) = getarnt"
    set treichweite($text) 1
    set text "$schiff2)($schiff1"
    set treichweite($text) 1
    putserv "PRIVMSG $tac($schiff2) :Ein Schiff kommt in Transporterreichweite"
    flug_schreiber $schiff2 "Ein Schiff kommt in Transporterreichweite"
    return 0
  }
  putlog "nichts ist getarnt :)"
  putserv "PRIVMSG $nick :$schiff($schiff1) $schiff($schiff2)"
  set treichweite($text) 1
  set text "$schiff2)($schiff1"
  set treichweite($text) 1
  putserv "PRIVMSG $tac($schiff1) :Ein schiff kommt in Transporterreichweite"
  putserv "PRIVMSG $tac($schiff2) :Ein Schiff kommt in Transporterreichweite"
  flug_schreiber $schiff1 "Ein Schiff kommt in Transporterreichweite"
  flug_schreiber $schiff2 "Ein Schiff kommt in Transporterreichweite"
putlog "ENDE"
  return 0
}

proc msg_waffenreichweite {nick uhost hand arg} {
  global channel wreichweite tac tarn schiff schiffszahl reichweite treichweite
  set ausser [lindex $arg 0]
  set schiff1 [lindex $arg 1]
  set schiff2 [lindex $arg 2]
  set text "$schiff1)($schiff2"
  if {$ausser == "ausser"} {
    if {$wreichweite($text) == 0} {
      putserv "PRIVMSG $nick :Die beiden Schiffe sind nicht in waffenreichweite!"
      return 0
    }
    if {$tarn($schiff1) == 1} {
      if {$tarn($schiff2) == 1} {
        putserv "PRIVMSG $nick :Die schiffe kommen ausser reichweite: $schiff($schiff1) $schiff($schiff2), aber beide sind getarnt"
        set wreichweite($text) 0
        set text "$schiff2)($schiff1"
        set wreichweite($text) 0
        return 0
      }
      putserv "PRIVMSG $nick :$schiff($schiff1) $schiff($schiff2) ausser waffenreichweite, $schiff($schiff1) getarnt"
      putserv "PRIVMSG $tac($schiff1) :$schiff($schiff2) ist nun ausser waffenreichweite"
      flug_schreiber $schiff1 "$schiff($schiff2) ausser waffenreichweite"
      set wreichweite($text) 0
      set text "$schiff2)($schiff1"
      set wreichweite($text) 0
      return 0
    }
    if {$tarn($schiff2) == 1} {
      putserv "PRIVMSG $nick :$schiff($schiff1) $schiff($schiff2) = getarnt"
      set wreichweite($text) 0
      set text "$schiff2)($schiff1"
      set wreichweite($text) 0
      putserv "PRIVMSG $tac($schiff2) :$schiff($schiff1) ist nun ausser Waffenreichweite"
      flug_schreiber $schiff2 "$schiff($schiff1) ist nun ausser Waffenreichweite"
      return 0
    }
    putserv "PRIVMSG $nick :$schiff($schiff1) $schiff($schiff2)"
    set wreichweite($text) 0
    set text "$schiff2)($schiff1"
    set wreichweite($text) 0
    putserv "PRIVMSG $tac($schiff1) :$schiff($schiff2) ist nun ausser Waffenreichweite"
    putserv "PRIVMSG $tac($schiff2) :$schiff($schiff1) ist nun ausser Waffenreichweite"
    flug_schreiber $schiff1 "$schiff($schiff2) ist nun ausser Waffenreichweite"
    flug_schreiber $schiff2 "$schiff($schiff1) ist nun ausser Waffenreichweite"
    return 0
  }
  if {$reichweite($text) == 0} {
    putserv "PRIVMSG $nick :Die beiden schiffe sind nicht mal noch in scannerreichweite.."
    return 0
  }
  if {$treichweite($text) == 0} {
    putserv "PRIVMSG $nick :Die beiden Schiffe sind nicht mal noch in transporterreichweite"
    return 0
  }
  if {$wreichweite($text) == 1} {
    putserv "PRIVMSG $nick :Die beiden schiffe sind bereits in waffenreichweite"
    return 0
  }
  if {$wreichweite($text) == 1} {
    putserv "PRIVMSG $nick :Die beiden Schiffe sind in waffenreichweite!"
    return 0
  }
  if {$tarn($schiff1) == 1} {
    if {$tarn($schiff2) == 1} {
      putserv "PRIVMSG $nick :Die schiffe kommen in waffenreichweite: $schiff($schiff1) $schiff($schiff2), aber beide sind getarnt"
      set wreichweite($text) 1
      set text "$schiff2)($schiff1"
      set wreichweite($text) 1
      return 0
    }
    putserv "PRIVMSG $nick :$schiff($schiff1) $schiff($schiff2) in waffenreichweite, $schiff($schiff1) getarnt"
    set wreichweite($text) 1
    set text "$schiff2)($schiff1"
    set wreichweite($text) 1
    putserv "PRIVMSG $tac($schiff1) :Ein Schiff kommt in Waffenreichweite"
    flug_schreiber $schiff1 "Ein Schiff kommt in Waffenreichweite"
    return 0
  }
  if {$tarn($schiff2) == 1} {
    putserv "PRIVMSG $nick :$schiff($schiff1) $schiff($schiff2) = getarnt"
    set wreichweite($text) 1
    set text "$schiff2)($schiff1"
    set wreichweite($text) 1
    putserv "PRIVMSG $tac($schiff2) :Ein Schiff kommt in Waffenreichweite"
    flug_schreiber $schiff2 "Ein Schiff kommt in Waffenreichweite"
    return 0
  }
  putserv "PRIVMSG $nick :$schiff($schiff1) $schiff($schiff2)"
  set wreichweite($text) 1
  set text "$schiff2)($schiff1"
  set wreichweite($text) 1
  putserv "PRIVMSG $tac($schiff1) :Ein Schiff kommt in Waffenreichweite"
  putserv "PRIVMSG $tac($schiff2) :Ein Schiff kommt in Waffenreichweite"
  flug_schreiber $schiff1 "Ein Schiff kommt in Waffenreichweite"
  flug_schreiber $schiff2 "Ein Schiff kommt in Waffenreichweite"
  return 0
}





proc msg_schilde {nick uhost hand arg} {
  global schildstat channel schiff schilde tac reichweite tarn schiffszahl
  set command [lindex $arg 0]
  set zaehler 0
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    if {$nick == $tac($zaehler)} {
      if {$tarn($zaehler) == 1} {
	putserv "privmsg $nick :Das Schiff ist getarnt, und kann daher die Schilde nicht aktivieren"
      }
      if {$command == "aktivieren"} {
	set zaehler2 0
	while {$zaehler2 < $schiffszahl} {
	  set zaehler2 [expr $zaehler2 + 1]
	  putlog "$zaehler2 Schiffszahl: $schiffszahl"
	  set text "$zaehler)($zaehler2"
	  if {$reichweite($text) == 1} {
	    putserv "PRIVMSG $tac($zaehler2) :$schiff($zaehler) faehrt die Schilde hoch"
            flug_schreiber $zaehler2 "$schiff($zaehler) faehrt die Schilde hoch"
	  }
	}
	putserv "PRIVMSG $nick :Schilde werden hochgefahren."
        flug_schreiber $zaehler "Die Schilde werden hochgefahren."
	set schildstat($zaehler) 1
      }
      if {$command == "deaktivieren"} {
	set zaehler2 0
	while {$zaehler2 < $schiffszahl} {
	  set zaehler2 [expr $zaehler2 + 1]
	  set text "$zaehler)($zaehler2"
	  if {$reichweite($text) == 1} {
	    putserv "PRIVMSG $tac($zaehler2) :$schiff($zaehler) deaktiviert ihre Schilde"
            flug_schreiber $zaehler2 "$schiff($zaehler) deaktivert ihre Schilde"
	  }
	}
	putserv "PRIVMSG $nick :Schilde deaktiviert"
        flug_schreiber $zaehler "Schilde werden deaktiviert"
	set schildstat($zaehler) 0
      }
    }
  }
}

proc msg_beam {nick uhost hand arg} {
  global warp tarn treichweite channel schiff schilde schildstat reichweite rpgmaster planet tac schiffszahl
  set beamnick [lindex $arg 0]
  set wort [lindex $arg 1]
  set ziel [lindex $arg 2]
  if {$beamnick == ""} {
    putserv "PRIVMSG $nick :verwendung (wegbeamen): beam <nick> to <ziel>"
    putserv "PRIVMSG $nick :oder (zurueckbeamen)  : beam <nick> from <schiff>"
  }
  set zaehler 0
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    if {$nick == $tac($zaehler)} {
      set zaehler2 0
      while {$zaehler2 < $schiffszahl} {
        set zaehler2 [expr $zaehler2 + 1]
        if {$ziel == $schiff($zaehler2)} {
          set channels $channel($zaehler)
          set text "$zaehler)($zaehler2"
          if {$reichweite($text) == 0} {
            putserv "PRIVMSG $nick :Dieses Schiff ist nicht in Scannerreichweite"
            return 0
          }
          if {$tarn($zaehler2) == 1} {
            putserv "PRIVMSG $nick :Dieses Schiff ist nicht in Scannerreichweite"
            return 0
          }
          if {$treichweite($text) == 0} {
            putserv "PRIVMSG $nick :Dieses Schiff ist nicht in Transporterreichweite"
            return 0          
          }
          if {$tarn($zaehler) == 1} {
            putserv "PRIVMSG $nick :Bevor gebeamt wird, muss die tarnung deaktiviert werden"
            return 0
          }
          if {$schilde($zaehler) == 1} {
            putserv "PRIVMSG $nick :Bevor gebeamt wird, muessen die Schilde deaktiviert werden."
            return 0
          }
          if {$schildstat($zaehler2) > 50} {
            if {$schilde($zaehler2) == 1} {
              putserv "PRIVMSG $nick :Dieses Schiff hat die Schilde aktiviert."
              return 0
            }
          }
          if {$warp($zaehler2) > 1} {
            putserv "PRIVMSG $nick :Ein beamen auf ein Schiff, das mit warpgeschwindigkeit fliegt, ist mit der derzeitigen technik nicht moeglich."
            return 0
          }
          if {$warp($zaehler) > 1} {
            putserv "PRIVMSG $nick :Ein beamen bei lichtgeschwindigkeit, ist mit der derzeitigen technik nicht moeglich"
            return 0
          }
          if {$wort == "to"} {
            puthelp "INVITE $beamnick $channel($zaehler2)"
            putchan $channel($zaehler) "$beamnick wird auf $schiff($zaehler2) gebeamt"
            putserv "PRIVMSG $tac($zaehler2) :$beamnick wird von $schiff($zaehler) auf dieses schiff gebeamt"
            flug_schreiber $zaehler "$beamnick wird auf $schiff($zaehler2) gebeamt"
            flug_schreiber $zaehler2 "$beamnick wird von $schiff($zaehler) auf dieses schiff gebeamt"
            putserv "KICK $channel($zaehler) $beamnick"
            putchan $channel($zaehler2) "$beamnick materialisiert sich."
            return 0
          }
          if {$wort == "from"} {
            puthelp "INVITE $beamnick $channel($zaehler)"
            putchan $channel($zaehler2) "$beamnick wird auf $schiff($zaehler) gebeamt"
            putserv "PRIVMSG $tac($zaehler2) :$beamnick wird von diesem schiff zu $schiff($zaehler) gebeamt."
            putserv "KICK $channel($zaehler2) $beamnick"
            putchan $channel($zaehler) "$beamnick materialisiert sich."
            return 0
          }
        }
      }
    }
  }
}


proc msg_com {nick uhost hand args} {
global com schiff channel tac msgtac msgpub msgco pubtac pubpub pubco comsg copub coco conn rpgmaster reichweite testruf ruf schiffszahl
set ziel [lindex $args 0]
set zaehler 0
while {$zaehler < $schiffszahl} {
set zaehler [expr $zaehler + 1]
if {$nick == $conn($zaehler)} {
set zaehler2 0
putlog "$zaehler2"
while {$zaehler2 < $schiffszahl} {
set zaehler2 [expr $zaehler2 + 1]
if {$ziel == $schiff($zaehler2)} {
if {$ruf($zaehler2) != 0} {
putserv "PRIVMSG $nick :$schiff($zaehler2) kommuniziert gerade"
return 0
}
if {$ruf($zaehler) != 0} {
putserv "PRIVMSG $nick :Ihr Schiff Kommuniziert gerade!"
return 0
}
set testruf($zaehler2) $zaehler
putserv "PRIVMSG $nick :$schiff($zaehler2) wird kontaktiert"
putserv "PRIVMSG $conn($zaehler2) :Sie werden von $schiff($zaehler) gerufen"
return 0
}
}
}
}
}


proc msg_antwort {nick uhost hand arg} {
  global schiff channel testruf ruf conn schiffszahl
  set zaehler 0
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    if {$nick == $conn($zaehler)} {
      if {$testruf($zaehler) == 0} {
	putserv "PRIVMSG $nick :Sie werden nicht gerufen!"
	return 0
      } else {
	set ver "$testruf($zaehler)"
	putchan $channel($zaehler) "Sie sind mit der Bruecke der $schiff($ver) verbunden"
	putchan $channel($ver) "Sie sind mit der Bruecke der $schiff($zaehler) verbunden"
	set testruf($zaehler) 0
	set ruf($zaehler) $ver
	set ruf($ver) $zaehler
	return 0
      }
    }
  }
}


proc pubm_com {nick uhost hand chan arg} {
  global schiff channel rufueberwach planet planetruf planetchan ruf schiffszahl
  set zaehler 0
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    if {$chan == $channel($zaehler)} {
      if {$ruf($zaehler) != 0} {
        set ver "$ruf($zaehler)"
	putchan $channel($ver) "$schiff($zaehler): $arg"
	return 0
      }
      return 0
    }
  }
}

proc msg_endcom {nick uhost hand arg} {
global schiff channel ruf schiffszahl conn

set zaehler 0
while {$zaehler < $schiffszahl} {
set zaehler [expr $zaehler + 1]
if {$nick == $conn($zaehler)} {
if {$ruf($zaehler) == 0} {
putserv "PRIVMSG $nick :Keine Kommunikation gestartet!"
} else {
set ver "$ruf($zaehler)"
set ruf($zaehler) 0
set ruf($ver) 0
putserv "PRIVMSG $conn($ver) :COM wurde beendet"
}
}
}
}




proc msg_impulse {nick uhost hand chan arg} {
set impulse [lrange $arg 0 end]

}

proc msg_phfeuer {nick uhost hand arg} {
  global rpgmaster channel schiff tac phzahl reichweite waffen wreichweite tarn schilde warp schiffszahl

  set zaehler 0

  set ziel [lindex $arg 0]
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    if {$nick == $tac($zaehler)} {
      set zaehler2 0
      while {$zaehler2 < $schiffszahl} {
        set zaehler2 [expr $zaehler2 + 1]
        if {$ziel == $schiff($zaehler2)} {
          set text "$zaehler)($zaehler2"
          if {$wreichweite($text) == 0 || $tarn($zaehler2) == 1} {
            putserv "PRIVMSG $nick :Dieses Schiff ist nicht in Waffenreichweite."
            return 0
          }
          if {$warp($zaehler) > 1} {
            putserv "PRIVMSG $nick :Phaser können nur mit Unterlichtgeschwindigkeit abgefeuert werden."
            return 0
          }
          if {$waffen($zaehler) == 0} {
            putserv "PRIVMSG $nick :Die Waffen wurden NICHT aktiviert."
            return 0
          }
          putserv "PRIVMSG $channel($zaehler2) :$schiff($zaehler) feuert Phaser auf $ziel"
          putserv "PRIVMSG $channel($zaehler) :Es wird auf $ziel geschossen"
          set angriffsfaktor [expr $phzahl($zaehler) / 2]
          if {$angriffsfaktor < $schilde($zaehler2)} {
            set schilde($zaehler2) [expr $schilde($zaehler2) - 10]
          }
          if {$angriffsfaktor == $schilde($zaehler2)} {
            set schilde($zaehler2) [expr $schilde($zaehler2) - 20]
          }
          if {$angriffsfaktor > $schilde($zaehler2)} {
            set schilde($zaehler2) [expr $schilde($zaehler2) - 50]
          }
          putserv "PRIVMSG $tac($zaehler2) :Noch $schilde($zaehler2) Schildenergie"
          putserv "PRIVMSG $tac($zaehler) :$schiff($zaehler2) hat noch $schilde($zaehler2) schildenergie"
          putserv "PRIVMSG $rpgmaster :$schiff($zaehler2) schildenergie: $schilde($zaehler2)"
        }
      }
    }
  }
}


proc pub_storychan {nick uhost hand chan arg} {
  global channel schiffszahl
  if {$chan == "#story"} {
    set zaehler 0
    while {$zaehler < $schiffszahl} {
      set zaehler [expr $zaehler + 1]
      putchan $channel($zaehler) "story: $arg"
    }
  }
}

proc pub_co1 {nick uhost hand chan arg} {
global co
set num [lindex $arg 0]
set co($num) [lindex $arg 1]
}

proc pub_conn1 {nick uhost hand chan arg} {
global conn
set num [lindex $arg 0]
set conn($num) [lindex $arg 1]
}

proc pub_tac1 {nick uhost hand chan arg} {
global tac
set num [lindex $arg 0]
set tac($num) [lindex $arg 1]
putlog "$num $tac($num)"
}


proc pub_variablen {nick uhost hand chan arg} {
putchan $chan "Folgende befehle:"
putchan $chan "!energie1 !energie2 !qtzahl1 !qtzahl2 !qtrampen1 !qtrampen2 !ptzahl1 !ptzahl2 !ptrampen1 !ptrampen2"
putchan $chan "!co1 !co2 !conn1 !conn2 !tac1 !tac2"
}

proc pub_energie1 {nick uhost hand chan arg} {
global energie
set num [lindex $arg 0]
set energie($num) [lindex $arg 1]
}

proc pub_schilde1 {nick uhost hand chan arg} {
global schilde
set num [lindex $arg 0]
set schilde($num) [lindex $arg 1]
}

proc pub_qtzahl1 {nick uhost hand chan arg} {
global qtzahl
set num [lindex $arg 0]
set qtzahl($num) [lindex $arg 1]
}

proc pub_qtrampen1 {nick uhost hand chan arg} {
global qtrampen
set num [lindex $arg 0]
set qtrampen($num) [lindex $arg 1]
}

proc pub_ptzahl1 {nick uhost hand chan arg} {
global ptzahl
set num [lindex $arg 0]
set ptzahl($num) [lindex $arg 1]
}

proc pub_ptrampen1 {nick uhost hand chan arg} {
global ptrampen
set num [lindex $arg 0]
set ptrampen($num) [lindex $arg 1]
}

proc msg_warp {nick uhost hand arg} {
  global channel schiff energie co conn tac reichweite warp warpziel warpfaktor rpgmaster schiffszahl
  set warpfaktor1 [lindex $arg 0]
  set ziel [lrange $arg 1 end]
  putlog "vor if-befehl"
  if {$ziel == ""} {
    putserv "PRIVMSG $nick :Verwendung: warp <warpfaktor> <ziel>"
  }
  putlog "WARP"
  set zaehler 0
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    if {$nick == $conn($zaehler)} {
      if {$warpfaktor1 > $warpfaktor($zaehler)} {
	putserv "PRIVMSG $nick :Dieses Schiff kann maximal $warpfaktor($zaehler) fliegen!"
	return 0
      }
      putlog "nach einigen if-befehlen :)"
      if {$warpfaktor1 == "0"} {
	putserv "PRIVMSG $nick :$schiff($zaehler) geht auf Unterlichtgeschwindigkeit"
	putchan $channel($zaehler) "$schiff($zaehler) geht auf Unterlichtgeschwindigkeit"
	putserv "PRIVMSG $rpgmaster :$schiff($zaehler) geht auf unterlichtgeschwindigkeit"
	set warp($zaehler) 0
	set warpziel($zaehler) ""
	return 0
      }
      set energieverbrauch [expr $warpfaktor1 * 100]
      if {$energieverbrauch > $energie($zaehler)} {
	putserv "PRIVMSG $nick :Nicht genug energie"
	return 0
      }
      putserv "PRIVMSG $nick :$schiff($zaehler) geht auf warp $warpfaktor1, zielort: $ziel"
      putchan $channel($zaehler) "$schiff($zaehler) geht auf warp $warpfaktor1, zielort: $ziel"
      putserv "PRIVMSG $rpgmaster :$schiff($zaehler) warp $warpfaktor1, $ziel / $zaehler"
      flug_schreiber $zaehler "Das Schiff geht auf warp $warpfaktor1, ziel: $ziel"
      set warp($zaehler) $warpfaktor1
      set warpziel($zaehler) $ziel
      set zaehler2 0
      while {$zaehler2 < $schiffszahl} {
        set zaehler2 [expr $zaehler2 + 1]
	set text "$zaehler)($zaehler2"
	if {$reichweite($text) == 1} {
          flug_schreiber $zaehler2 "$schiff($zaehler) geht auf warp $warpfaktor1, ziel: $ziel"
	  putserv "PRIVMSG $tac($zaehler2) :$schiff($zaehler) geht auf warp $warpfaktor1, zielort: $ziel"
	}
      }
      set energie($zaehler) [expr $energie($zaehler) - $energieverbrauch]
    }
  }
}


proc pub_rpgstats {nick uhost hand chan arg} {
global schiff1 schiff2 ptzahl1 ptzahl2 ptrampen1 ptrampen2 schilde1 schilde2 channel1 channel2 qtzahl1 qtzahl2 qtrampen1 qtrampen2 tac1 tac2 conn1 conn2 co1 co2 energie1 energie2
putchan $chan "1. $schiff1 ($channel1): $ptzahl1 (pt) $ptrampen1 (ptrampen) $qtzahl1 (QT) $qtrampen1 (qtrampen) $schilde1 (schilde) $energie1 (energie)"
putchan $chan "Besatzung: tac/sec: $tac1 conn: $conn1 CO: $co1"
putchan $chan "2. $schiff2 ($channel2): $ptzahl2 (pt) $ptrampen2 (ptrampen) $qtzahl2 (QT) $qtrampen2 (qtrampen) $schilde2 (schilde) $energie2 (energie)"
putchan $chan "Besatzung: tac/sec: $tac2 conn: $conn2 CO: $co2"
}


proc msg_beenden {nick uhost hand arg} {
  global channel schiff schiffszahl logbuchc
  set zaehler 0
  set dir "rpg_[stardate mit]"
  exec mkdir /home/bot/public_html/log/$dir
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    putserv "MODE $channel($zaehler) -i"
    putserv "MODE $channel($zaehler) -m"
    putchan $channel($zaehler) "DAS RPG WURDE BEENDET"
    putchan $channel($zaehler) "We are the Borg, resistance is futile"
    flug_schreiber $zaehler "Das RPG wurde beendet."
    exec cp /home/bot/Data/$logbuchc($zaehler) /home/bot/public_html/log/$dir/$schiff($zaehler)
  }
}

proc pub_rufen_planet_schiff {nick uhost hand chan arg} {
global channel1 channel2 schiff1 schiff2 tac1 tac2 planet rufueberwach conn1 conn2
if {$rufueberwach == 1} {
global planetruf
set planetruf $channel1
putchan $channel1 "Sie sind mit $planet verbunden"
bind pubm * * pubm_com
putlog "bind pubm * * pubm_com"
#bind pubm * * pubm_planetchanneleins
return 0
}
if {$rufueberwach == 2} {
global planetruf
set planetruf $channel2
putchan $channel2 "Sie sind mit $planet verbunden"
bind pubm * * pubm_com
putlog "bind pubm * * pubm_com"
# bind pubm * * pubm_planetchannelzwei
return 0
}
set planet [string range $chan 1 end]
set com [lindex $arg 0]
if {$com == $schiff1} {
global planetruf planetchan
set planetchan $chan
set planetruf $channel1
putlog "$conn1 wird kontaktiert ($planet)"
putserv "PRIVMSG $conn1 :Sie werden von dem Planet $planet gerufen (sie koennen dieses gespraech nur auf den schirm leiten! 'planet')"
putchan $chan "$conn1 wird kontaktiert"
bind msg - planet planetruf
}
if {$com == $schiff2} {
global planetruf
global planetchan
set planetchan $chan
set planetruf $channel2
putserv "PRIVMSG $conn2 :Sie werden von dem Planet $planet gerufen (sie koennen dieses gespraech nur auf den schirm leiten! 'planet'"
putchan $chan "$conn2 wird kontaktiert"
bind msg - planet planetruf
}
}

#proc pub_end {bindtest} {
#global channel1 channel2 planet rufueberwach
#set rufueberwach 0
#if {$bindtest == 1} {
#unbind pubm * * pubm_planetchanneleins
#putchan $channel1 "$planet ende"
#}
#if {$bindtest == 2} {
#unbind pubm * * pubm_planetchannelzwei
#putchan $channel2 "$planet ende"
#}
#}


proc planetruf {nick uhost hand arg} {
global planetruf channel1 channel2 tac1 tac2 planet planetchan conn1 conn2
unbind msg - planet planetruf
putlog "$nick $tac1 $tac2 $planetruf $channel1 $planetchan"
if {$planetruf == ""} { return 0 }
if {$nick != $conn1} {
if {$nick != $conn2} { return 0 }
}
if {$planetruf == $channel1} {
if {$nick == $conn1} {
bind pubm * * pubm_com
global rufueberwach
set rufueberwach 1
putchan $channel1 "Sie sind mit $planet verbunden"
}
}
if {$planetruf == $channel2} {
if {$nick == $conn2} {
putlog "conn2"
bind pubm * * pubm_com
global rufueberwach
set rufueberwach 2
putchan $channel2 "Sie sind mit $planet verbunden"
}
}
}


#proc pubm_planetchanneleins {nick uhost hand chan arg} {
#global channel1 planetruf planet planetchan
#if {$chan == $planetchan} {
#set ende [lindex $arg 0]
#if {$ende == "!end"} {
#pub_end 1
#}
#putchan $channel1 "$planet: $arg"
#}
#}

#proc pubm_planetchannelzwei {nick uhost hand chan arg} {
#global channel2 planetruf planet planetchan
#if {$chan == $planetchan} {
#set ende [lindex $arg 0]
#if {$ende == "!end"} {
#pub_end 2
#}
#putchan $channel2 "$planet: $arg"
#}
#}

#set schiff(1) "-"
#putlog "$schiff(1)"
#set schiff(2) "-"
#set schiff(3) "-"
#set channel(1) "-"
#set channel(2) "-"
#set channel(3) "-"

proc msg_startrpg {nick uhost hand arg} {
  global ptnachl qtnachl schiffszahl durchlauf logbuche treichweite channel schiff schildstat reichweite rpgmaster rufueberwach waffen tarn wreichweite co conn tac chi cou med fo warp warpziel impulse impulseziel testruf ruf logbuchc
  set schiffszahl [lindex $arg 0]
  if {$schiffszahl < 2} {
    putserv "PRIVMSG $nick :MINDESTENS 2 schiffe!"
    return 0
  } 
  set durchlauf 0
  bind pubm * * pubm_com
  while {$durchlauf < $schiffszahl} {
    set ptnachl($durchlauf) 1
    set qtnachl($durchlauf) 1
    set durchlauf [expr $durchlauf + 1]
    set channel($durchlauf) [lindex $arg $durchlauf]
    set schiff($durchlauf) [lindex $arg [expr $durchlauf + $schiffszahl]]
    set tarn($durchlauf) 0
    set rufueberwach 0
    set zaehler 0

    putlog "nach; $logbuche($durchlauf)"
    while {$zaehler < $schiffszahl} {
      set zaehler [expr $zaehler + 1]
      set testruf($zaehler) 0
      set ruf($zaehler) 0
      set text "$durchlauf)($zaehler"
      set reichweite([string trim $text]) 0
      set wreichweite([string trim $text]) 0
      set treichweite([string trim $text]) 0
      set text "$zaehler)($durchlauf"
      set wreichweite([string trim $text]) 0
      set reichweite([string trim $text]) 0
      set treichweite([string trim $text]) 0
      putlog "Test"
    }
    set fh [open $logbuchc($durchlauf) w]
    puts $fh "--------------------LOGBUCH-------------------"
    close $fh
    set schildstat($durchlauf) 0
    set waffen($durchlauf) 0
    set warp($durchlauf) 0
    set warpziel($durchlauf) ""
    set impulse($durchlauf) 0
    set impulseziel($durchlauf) ""
    set rpgmaster $nick 
    schiffwahl $durchlauf
    putserv "MODE $channel($durchlauf) +i"
    putserv "MODE $channel($durchlauf) +m"
    vor $co($durchlauf) $channel($durchlauf)
#    if {$fo($durchlauf) != ""} {
#      vor $fo($durchlauf) $channel($durchlauf)
#    }
    vor $tac($durchlauf) $channel($durchlauf)
    if {$chi($durchlauf) != ""} {
      vor $chi($durchlauf) $channel($durchlauf)
    }
    if {$cou($durchlauf) != ""} {
      vor $cou($durchlauf) $channel($durchlauf)
    }
    if {$med($durchlauf) != ""} {
      vor $med($durchlauf) $channel($durchlauf)
    }
    vor $conn($durchlauf) $channel($durchlauf)
    putserv "PRIVMSG $nick :$schiff($durchlauf)"
    putchan $channel($durchlauf) "Es wird ein RPG gestartet."
    bind pubm n * pub_storychan
    bind pub * !ruf pub_rufen_planet_schiff
  }
}

proc vor {nick chan} {
if {$nick != "Vadm_Poul"} {
if {$nick != "Poul"} {
putserv "MODE $chan -o $nick"
putserv "MODE $chan +v $nick"
}
}
}

set planetchan ""
set planet ""
#set tac(1) "Vadm_Poul"
#set tac(2) "Poul"
#set co(1) "Vadm_Poul"
#set co(2) "Poul"
#set conn(1) "Vadm_Poul"
#set conn(2) "Poul"
#set fo(1) "Vadm_Poul"
#set fo(2) "Poul"
#set med(1) "Vadm_Poul"
#set med(2) "Poul"
#set cou(1) "Vadm_Poul"
#set cou(2) "Poul"
#set chi(1) "Vadm_Poul"
#set chi(2) "Poul"
#set tac(3) "Vadm_Poul"
#set tac(4) "Poul"
#set co(3) "Vadm_Poul"
#set co(4) "Poul"
#set conn(3) "Vadm_Poul"
#set conn(4) "Poul"
#set fo(3) "Vadm_Poul"
#set fo(4) "Poul"
#set med(3) "Vadm_Poul"
#set med(4) "Poul"
#set cou(3) "Vadm_Poul"
#set cou(4) "Poul"
#set chi(3) "Vadm_Poul"
#set chi(4) "Poul"
#set tac(5) "Vadm_Poul"
#set tac(6) "Poul"
#set co(5) "Vadm_Poul"
#set co(6) "Poul"
#set conn(5) "Vadm_Poul"
#set conn(6) "Poul"
#set fo(5) "Vadm_Poul"
#set fo(6) "Poul"
#set med(5) "Vadm_Poul"
#set med(6) "Poul"
#set cou(5) "Vadm_Poul"
#set cou(6) "Poul"
#set chi(5) "Vadm_Poul"
#set chi(6) "Poul"



proc schiffwahl {durchlauf} {
global com msgtac msgpub msgco pubtac pubpub pubco comsg copub coco schiff channel tac conn co fo schiffszahl logbuchc
set com 0
set msgtac 0
set msgpub 0
set msgco 0
set pubtac 0
set pubpub 0
set pubco 0
set comsg 0
set copub 0
set coco 0
if {$schiff($durchlauf) == "Bavarian"} {
        global ptzahl ptrampen qtzahl qtrampen schilde energie phzahl tarnvorrichtung warpfaktor
        set ptzahl($durchlauf) 60
        set ptrampen($durchlauf) 4
        set qtzahl($durchlauf) 0
        set qtrampen($durchlauf) 0
        set energie($durchlauf) 2500
        set schilde($durchlauf) 450
 	set phzahl($durchlauf) 400
 	set tarnvorrichtung($durchlauf) 0
 	set warpfaktor($durchlauf) 9.98
        putchan $channel($durchlauf) "Dies ist die U.S.S. Bavarian, es hat $ptzahl($durchlauf) Photonentorpedos, $ptrampen($durchlauf) Photonentorpedorampen, $qtzahl($durchlauf) Quantentorpedos, $qtrampen($durchlauf) Quantentorpedoramen, $schilde($durchlauf) Schildenergie, $energie($durchlauf) Energie und keine Tarnvorrichtung."
}
if {$schiff($durchlauf) == "Borg"} {
        global ptzahl ptrampen qtzahl qtrampen schilde energie phzahl tarnvorrichtung warpfaktor
        set ptzahl($durchlauf) 500
        set ptrampen($durchlauf) 50
        set qtzahl($durchlauf) 200
        set qtrampen($durchlauf) 20
        set energie($durchlauf) 25000
        set schilde($durchlauf) 32000
        set phzahl($durchlauf) 1000
        set tarnvorrichtung($durchlauf) 0
        set warpfaktor($durchlauf) 11
}
if {$schiff($durchlauf) == "DS9"} {
        global ptzahl ptrampen qtzahl qtrampen schilde energie phzahl tarnvorrichtung warpfaktor
        set ptzahl($durchlauf) 500
        set ptrampen($durchlauf) 50
        set qtzahl($durchlauf) 200
        set qtrampen($durchlauf) 20
        set energie($durchlauf) 25000
        set schilde($durchlauf) 32000
        set phzahl($durchlauf) 1000
        set tarnvorrichtung($durchlauf) 0
        set warpfaktor($durchlauf) 1
}
if {$schiff($durchlauf) == "Excelsior"} {
        global ptzahl ptrampen qtzahl qtrampen schilde energie phzahl tarnvorrichtung warpfaktor
        set ptzahl($durchlauf) 50
        set ptrampen($durchlauf) 2
        set qtzahl($durchlauf) 0
        set qtrampen($durchlauf) 0
        set energie($durchlauf) 2500
        set schilde($durchlauf) 450 
        set phzahl($durchlauf) 400  
        set tarnvorrichtung($durchlauf) 1
        set warpfaktor($durchlauf) 7
}
if {$schiff($durchlauf) == "Defiant"} {
	global ptzahl ptrampen qtzahl qtrampen schilde energie phzahl tarnvorrichtung warpfaktor
        set ptzahl($durchlauf) 50
        set ptrampen($durchlauf) 2
        set qtzahl($durchlauf) 20
        set qtrampen($durchlauf) 2
        set energie($durchlauf) 2500
        set schilde($durchlauf) 450
        set phzahl($durchlauf) 400
        set tarnvorrichtung($durchlauf) 1
        set warpfaktor($durchlauf) 9.9
        putchan $channel($durchlauf) "Dies ist die U.S.S. Defiant, es hat $ptzahl($durchlauf) Photonentorpedos, $ptrampen($durchlauf) Photonentorpedorampen, $qtzahl($durchlauf) Quantentorpedos, $qtrampen($durchlauf) Quantentorpedoramen, $schilde($durchlauf) Schildenergie, $energie($durchlauf) Energie und eine Tarnvorrichtung."
}
if {$schiff($durchlauf) == "Quark"} {
        global ptzahl ptrampen qtzahl qtrampen schilde energie phzahl tarnvorrichtung warpfaktor
        set ptzahl($durchlauf) 50  
        set ptrampen($durchlauf) 2
        set qtzahl($durchlauf) 20   
        set qtrampen($durchlauf) 2   
        set energie($durchlauf) 2500 
        set schilde($durchlauf) 450
        set phzahl($durchlauf) 400
        set tarnvorrichtung($durchlauf) 1
 	set warpfaktor($durchlauf) 9.9
        putchan $channel($durchlauf) "Dies ist die Quark, es hat $ptzahl($durchlauf) Photonentorpedos, $ptrampen($durchlauf) Photonentorpedorampen, $qtzahl($durchlauf) Quantentorpedos, $qtrampen($durchlauf) Quantentorpedoramen, $schilde($durchlauf) Schildenergie, $energie($durchlauf) Energie und eine Tarnvorrichtung."
}
if {$schiff($durchlauf) == "Civic"} {
	global ptzahl ptrampen qtzahl qtrampen schilde energie phzahl tarnvorrichtung warpfaktor
        set ptzahl($durchlauf) 150
        set ptrampen($durchlauf) 10
        set qtzahl($durchlauf) 30
        set qtrampen($durchlauf) 5
        set energie($durchlauf) 700
        set schilde($durchlauf) 2565
        set phzahl($durchlauf) 400
        set tarnvorrichtung($durchlauf) 1
        set warpfaktor($durchlauf) 9.9
        putchan $channel($durchlauf) "Dies ist die Civic, ein Klingonischer Schlachtkreuzer, es hat $ptzahl($durchlauf) Photonentorpedos, $ptrampen($durchlauf) Photonentorpedorampen, $qtzahl($durchlauf) Quantentorpedos, $qtrampen($durchlauf) Quantentorpedoramen, $schilde($durchlauf) Schildenergie, und $energie($durchlauf) Energie."
}
if {$schiff($durchlauf) == "Einstein"} {
	global ptzahl ptrampen qtzahl qtrampen schilde energie phzahl tarnvorrichtung warpfaktor
        set ptzahl($durchlauf) 120
        set ptrampen($durchlauf) 2
        set qtrampen($durchlauf) 1
        set qtzahl($durchlauf) 10
        set schilde($durchlauf) 450
        set energie($durchlauf) 1610
        set phzahl($durchlauf) 300
        set tarnvorrichtung($durchlauf) 0
        set warpfaktor($durchlauf) 5.0
	putchan $channel($durchlauf) "Dies ist die U.S.S. Einstein ein schiff der NOVELL klasse, es hat $ptzahl($durchlauf) Photonentporpedos, $ptrampen($durchlauf) Photonentorpedorampen, $qtzahl($durchlauf) Quantentorpedos, $qtrampen($durchlauf) Quantentorpedorampen und $schilde($durchlauf) Schildenergie"
}
if {$schiff($durchlauf) == "Revenge"} {
	global ptzahl ptrampen qtzahl qtrampen schilde energie phzahl tarnvorrichtung warpfaktor
        set ptzahl($durchlauf) 150
        set ptrampen($durchlauf) 2
        set qtzahl($durchlauf) 25
        set qtrampen($durchlauf) 0
        set schilde($durchlauf) 350
        set energie($durchlauf) 3350
        set phzahl($durchlauf) 1100
        set tarnvorrichtung($durchlauf) 0
        set warpfaktor($durchlauf) 9.9
        putchan $channel($durchlauf) "Dies ist die U.S.S. Revenge ein Schiff der Galaxy  klasse, es hat $ptzahl($durchlauf) Photonentorpedos, $ptrampen($durchlauf) Photonentorpedorampen, $qtzahl($durchlauf) Quantentorpedos, $qtrampen($durchlauf) Quantentorpedorampen und $schilde($durchlauf) Schildenergie"
}
flug_schreiber $durchlauf "Logbuch der $schiff($durchlauf)"
flug_schreiber $durchlauf "CO:		$co($durchlauf)"
flug_schreiber $durchlauf "FO:		$fo($durchlauf)"
flug_schreiber $durchlauf "CONN:	$conn($durchlauf)"
flug_schreiber $durchlauf "Tac/Sec:	$tac($durchlauf)"
#flug_schreiber $durchlauf "MED:		$med($durchlauf)"
#flug_schreiber $durchlauf "CHI:		$chi($durchlauf)"
}

proc msg_ptfeuer {nick uhost hand arg} {
  global ptnachl reichweite schiff ptzahl ptrampen schilde channel co conn tac schildstat waffen tarn wreichweite schiffszahl
  set anz [lindex $arg 0]
  set ziel [lindex $arg 1]
  if {$ziel == ""} {
    putserv "PRIVMSG $nick :verwendung: pt <anzahl> <ziel>"
    return 0
  }
  set zaehler 0
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    if {$nick == $tac($zaehler)} {
      if {$ptnachl($zaehler) == 0} {
        putserv "PRIVMSG $nick :Die PTs werden gerade nachgeladen - bitte gedulden !"
        return 0
      }
      if {$anz > $ptzahl($zaehler)} {
	putserv "PRIVMSG $nick :es sind nur $ptzahl($zaehler) Photonentorpedos verfuegbar..."
	return 0
      }
      if {$anz > $ptrampen($zaehler)} {
	putserv "PRIVMSG $nick :Es sind nur $ptrampen($zaehler) Rampen verfuegbar..."
	return 0
      }
      set zaehler2 0
      while {$zaehler2 < $schiffszahl} {
	set zaehler2 [expr $zaehler2 + 1]
	if {$ziel == $schiff($zaehler2)} {
	  set text "$zaehler)($zaehler2"
	  putlog "$zaehler)($zaehler2"
	  if {$reichweite($text) == 0} {
	    putserv "PRIVMSG $nick :Kein schiff in reichweite"
	    return 0
	  }
	  if {$tarn($zaehler2) == 1} {
	    putserv "PRIVMSG $nick :Kein schiff in reichweite"
	    return 0
	  }
	  if {$wreichweite($text) == 0} {
	    putserv "PRIVMSG $nick :Kein schiff in waffenreichweite"
	    return 0
	  }
#if {$waffen($zaehler) == 0} {
#putserv "PRIVMSG $nick :Die Waffen sind nicht aktiv..."
#return 0
#}
	  putchan $channel($zaehler) "Es werden $anz Photonentorpedos auf $schiff($zaehler2) abgefeuert"
	  putchan $channel($zaehler2) "Es werden $anz Photonentorpedos von $schiff($zaehler) abgefeuert"
          flug_schreiber $zaehler "Es werden $anz Photonentorpedos auf $schiff($zaehler2) abgefeuert."
          flug_schreiber $zaehler2 "Es wurden $anz Photonentorpedos von $schiff($zaehler) abgefeuert !"
	  set ptzahl($zaehler) [expr $ptzahl($zaehler) - $anz]
	  set angriffsfaktor [expr $anz * 250]
	  if {$schildstat($zaehler) == 0} {
	    set tot [rechnetot]
	    putchan $channel($zaehler2) "die schilde sind NICHT aktiv."
	    putserv "PRIVMSG $nick :Die schilde von $schiff($zaehler2) sind nicht aktiv, bei dem treffer, ist $tot gestorben"
            flug_schreiber $zaehler2 "Die Schilde sind nciht aktiv, bei den treffer wurde $tot getoetet"
	    if {[string index $tot 4] == "T"} {
	      putchan $channel($zaehler2) "Nachdem die Torpedos eingeschlagen hat, kommt es zu einer plasmaentladung"
	      set tac($zaehler2) ""
	      rechne_tot_betaeubt $channel($zaehler2) $tac($zaehler2)
	      return 0
	    }
	    if {[string index $tot 4] == "K"} {
	      putchan $channel($zaehler2) "Waehrend die Torpedos einschlagen, kommt es zu einer kraeftigen erschuetterung"
	      set co($zaehler2) ""
	      rechne_tot_betaeubt $channel($zaehler2) $co($zaehler2)
	      return 0
	    }
	    if {[string index $tot 4] == "C"} {
	      putchan $channel($zaehler2) "Nachdem die Torpedos eingeschlagen hat, kommt es zu einer plasmaentladung"
	      set conn($zaehler2) ""
	      rechne_tot_betaeubt $channel($zaehler2) $conn($zaehler2)
              return 0
	    }
	  }
	  if {$angriffsfaktor < $schilde($zaehler2)} {
	    set schilde($zaehler2) [expr $schilde($zaehler2) - 10]
          }
          if {$angriffsfaktor == $schilde($zaehler2)} {
	    set schilde($zaehler2) [expr $schilde($zaehler2) - 20]
          }
          if {$angriffsfaktor > $schilde($zaehler2)} {
	    set schilde($zaehler2) [expr $schilde($zaehler2) - 50]
          }
          putserv "PRIVMSG $tac($zaehler2) :Schild energie bei: $schilde($zaehler2)"
          putserv "PRIVMSG $tac($zaehler) :$schiff($zaehler2): $schilde($zaehler2) schildenergie"
          flug_schreiber $zaehler2 "Schildenergie bei: $schilde($zaehler2)"
          flug_schreiber $zaehler "$schiff($zaehler2)'s schildenergie: $schilde($zaehler2)"
          set ptnachl($zaehler) 0
          utimer 10 "nachl $zaehler pt"
        }
      }
    }
  }
}

proc rechnetot {} {
set tot [rand 6]
if {$tot == 1} {
set tot "der Taktische Offizier"
return $tot
}
if {$tot == 0} {
set tot "der Kommandierender Offizier"
return $tot
}
if {$tot == 3} {
set tot "der CONN Offizier"
return $tot
}
set tot "ein Mannschaftsmitglied"
}



proc rechne_tot_betaeubt {chan ziel} {
set tb [rand 5]
if {$tb < 3} {
putchan $chan "$ziel faellt schwer verletzt zu boden"
putserv "MODE $chan -v $ziel"
posten_uebernahme $ziel $chan
} else {
putchan $chan "$ziel wird Pulverisiert"
putserv "KICK $chan $ziel"
posten_uebernahme $ziel $chan
}
}



proc msg_qtfeuer {nick uhost hand arg} {
global reichweite schiff qtzahl qtrampen schilde channel co conn tac schildstat waffen tarn wreichweite schiffszahl
  set anz [lindex $arg 0]
  set ziel [lindex $arg 1]
  if {$ziel == ""} {
    putserv "PRIVMSG $nick :verwendung: qt <anzahl> <ziel>"
    return 0
  }
  set zaehler 0
  while {$zaehler < $schiffszahl} {
    set zaehler [expr $zaehler + 1]
    if {$nick == $tac($zaehler)} {
      if {$anz > $qtzahl($zaehler)} {
	putserv "PRIVMSG $nick :es sind nur $qtzahl($zaehler) verfuegbar..."
	return 0
      }
      if {$anz > $qtrampen($zaehler)} {
	putserv "PRIVMSG $nick :Es sind nur $qtrampen($zaehler) verfuegbar..."
	return 0
      }
      set zaehler2 0
      while {$zaehler2 < $schiffszahl} {
	set zaehler2 [expr $zaehler2 + 1]
	putlog "$zaehler2  $ziel   $schiff($zaehler2)"
	if {$ziel == $schiff($zaehler2)} {
	  putlog "$zaehler $zaehler2 ... $schiff($zaehler) $schiff($zaehler2)"
	  set text "$zaehler)($zaehler2"
	  if {$reichweite($text) == 0} {
	    putserv "PRIVMSG $nick :Kein schiff in reichweite"
	    return 0
	  }
	  if {$tarn($zaehler2) == 1} {
	    putserv "PRIVMSG $nick :Kein schiff in reichweite"
	    return 0
	  }
	  if {$wreichweite($text) == 0} {
	    putserv "PRIVMSG $nick :Kein schiff in waffenreichweite"
	    return 0
	  }
	  if {$waffen($zaehler) == 0} {
	    putserv "PRIVMSG $nick :Die Waffen sind nicht aktiv..."
	    return 0
	  }
	  putchan $channel($zaehler) "Es werden $anz Quantenentorpedos auf $schiff($zaehler2) abgefeuert"
	  putchan $channel($zaehler2) "Es werden $anz Quantentorpedos von $schiff($zaehler) abgefeuert"
	  flug_schreiber $zaehler "Es werden $anz Quantentorpedos auf $schiff($zaehler) abgefeuert."
	  set qtzahl($zaehler) [expr $qtzahl($zaehler) - $anz]
	  set angriffsfaktor [expr $anz * 250]
	  if {$schildstat($zaehler) == 0} {
 	    set tot [rechnetot]
 	    putchan $channel($zaehler2) "die schilde sind NICHT aktiv."
	    putserv "PRIVMSG $nick :Die schilde von $schiff($zaehler2) sind nicht aktiv, bei dem treffer, ist $tot gestorben"
	    if {[string index $tot 4] == "T"} {
	      putchan $channel($zaehler2) "Nachdem die Torpedos eingeschlagen hat, kommt es zu einer plasmaentladung"
	      set tac($zaehler2) ""
	      rechne_tot_betaeubt $channel($zaehler2) $tac($zaehler2)
	      return 0
	    }
	    if {[string index $tot 4] == "K"} {
	      putchan $channel($zaehler2) "Waehrend die Torpedos einschlagen, kommt es zu einer kraeftigen erschuetterung"
	      set co($zaehler2) ""
	      rechne_tot_betaeubt $channel($zaehler2) $co($zaehler2)
	      return 0
	    }
	    if {[string index $tot 4] == "C"} {
	      putchan $channel($zaehler2) "Nachdem die Torpedos eingeschlagen hat, kommt es zu einer plasmaentladung"
	      set conn($zaehler2) ""
	      rechne_tot_betaeubt $channel($zaehler2) $conn($zaehler2)
	      return 0
	    }
	  }
	  if {$angriffsfaktor < $schilde($zaehler2)} {
	    set schilde($zaehler2) [expr $schilde($zaehler2) - 10]
	  }
	  if {$angriffsfaktor == $schilde($zaehler2)} {
	    set schilde($zaehler2) [expr $schilde($zaehler2) - 20]
	  }
	  if {$angriffsfaktor > $schilde($zaehler2)} {
	    set schilde($zaehler2) [expr $schilde($zaehler2) - 50]
	  }
 	  putserv "PRIVMSG $tac($zaehler2) :Schild energie bei: $schilde($zaehler2)"
	  putserv "PRIVMSG $tac($zaehler) :$schiff($zaehler2): $schilde($zaehler2) schildenergie"
        }
      }
    }
 }
}

proc nachl {schnr art} {
  global qtnachl ptnachl

  putlog "$schnr - $art weg"
  if {$art == "qt"} {
    set qtnachl($schnr) 1
  } else {
    set ptnachl($schnr) 1
  }
}

putlog "Pouls RPG script geladen"
putlog "(C) by Poul (UFP) 1999"
putlog "Dieses script ist NUR fuer und in der UFP zu verwenden, alle anderen verwendungen, muessen von Poul (hp@devnull.atnet.at) bestaetigt werden."