brain.tcl

Eggdrop TCL that can learn from users and the information is stored in brain.db, a separate file. Brain.tcl tested on eggdrop1.4

Postat de	Copyright	Categorie	Review user	Vizualizari	Data
btc	Gehirn	games	Cod netestat	481	2023-12-24 23:24:21

# Wer diesen text loescht oder veraendert ist lame :-)
#
# script by: IrAl^KbK
# update by: Puchalke
#
# email: iral_kbk@web.de ; iral_kbk@gmx.de ; kotmann@gmx.de
#
# Brain.tcl tested on eggdrop1.4
# 
# ein kleines labber-script, ich habe nicht vor weitere verbesserte versionen
# davon herauszugeben, wenn ihr dazu lust habt, wuerde es mich freuen
# wenn ihr mir euren code senden wuerdet, weil mich diese art KI 
# sehr interessiert.
#
# dieses script ist fuer deutsche sprache ausgelegt, sollte aber in
# englisch auch funktionieren.
#
# gruesse zum erschaffer des 3xBot.tcl, dem ich zu verdanken hab, das ich
# das letzte problem mit einem befehl aus seinem script loesen konnte...
# auf den waere ich ohne dem script wahrscheinlich erst nach einem halben
# jahr gekommen :-)

### variablen ###
# hier den path von der brain-file eingeben (wird beim ersten wort erstellt)
# das verzeichniss muss gegebenfalls angelegt werden.
######!WICHTIG!######

set brain_brain_url  "./brain.db"

# dient dazu, dass der bot nicht saetze, in denen sein eigener name vorkommt, lernt
set botsnick [string range $botname 0 [expr [string last ! $botname]-1]]

# von folgenden usern wird nichts gelernt. hier keine wildcards benutzen!
set dont_learn_from "user1 user2"

# auf folgende user wird nicht reagiert
set dont_react_to   "user3"

# Hier die Channels eingeben auf denen der Bot reden soll. 
# "*" fuer alle Channels
set add_chan "#channel1"

# Hier die Channels eingeben auf denen der Bot saetze sammeln soll. 
# "*" fuer alle Channels
set add_shan "#channel1 #channel2 #channel3" 

# die trefferquote ( je hoeher die zahl, desto mehr redet der bot, aber 
# die cpu muss drunter leiden :-)
# der wert 10550 war bei meinem bot (linux-kernel 2.2.16 500mhz-cpu) kein
# problem, um den bot gegen floods zu schuetzen sollte man es nicht ueber
# 500 setzen schaetze ich mal *g*
# 150 ist der standartwert, wenn der bot nicht sofort loslabbert sollte
# man sich nicht wundern, weil er erstmal saetze sammeln muss. ab 16000
# zeilen sollte es schon ganz gut gehen

set brain_treffer 200


# ein paar feineinstellungen, keine von den zahlen darf den
# in $brain_treffer gesetzten wert ueberschreiten
# je kleiner der wert,desto besser. man sollte aber nicht uebertreiben,
# weil die cpu auslastung hochgeht. am besten einfach so lassen :-)

# moeglichst viele woerter treffen. je groesser der wert, desto eher aufgabe
set b_subbbbb 0

# weniger woerter treffen
set b_sub [expr $brain_treffer * 0.1]

# noch weniger
set b_subbb [expr $brain_treffer * 0.5]

# nach einzelnen woertern suchen
set b_subbbb [expr $brain_treffer * 0.9]

#################

##################### do not edit anything below ###############################

### binds ###
bind pubm - * brain_add
bind pubm - * brain_readfiles
#############



#######################
#### woerter adden ####
#######################

# returns:
# 0: satz gelernt
# 1: aus diesem channel soll nichts gelernt werden
# 2: satz nicht gelernt, da botname drin vorkam
# 3: satz nicht gelernt, da von nick nichts gelernt werden darf
# 4: satz bereits im hirn vorhanden

proc brain_add { nick uhost hand chan arg } {
	global brain_brain_url add_shan botsnick dont_learn_from

	if {([lsearch -exact $add_shan $chan] == -1) && ($add_shan != "*")} {return 1}
	
	set arg_low [join [string tolower [lindex $arg 0]]]
	if { ([string match *$botsnick* $arg_low] > 0)
		|| ([lsearch -exact $arg_low \#] >= 0)
		|| ([lsearch -exact $arg_low ign] >= 0) } {
		return 2
	}
	
	if { ([lsearch -exact $dont_learn_from $nick] >= 0)} {
		return 3
	}
	
	set msg [lrange $arg 0 end]
	set tmpfile [open $brain_brain_url a+]
	
	regsub -all -- Ä $msg Ae msg
	regsub -all -- Ü $msg Ue msg
	regsub -all -- Ö $msg Oe msg
	regsub -all -- ä $msg ae msg
	regsub -all -- ü $msg ue msg
	regsub -all -- ö $msg oe msg
	regsub -all -- ß $msg ss msg
	regsub -all -- \\\\ $msg \\\\\\\\ msg
	regsub -all -- \\\[ $msg \\\\\[ msg
	regsub -all -- \\\] $msg \\\\\] msg
	regsub -all -- \\\} $msg \\\\\} msg
	regsub -all -- \\\{ $msg \\\\\{ msg
	regsub -all -- \\\" $msg \\\\\" msg
	
	set sentence [join $msg]
	
	puts $tmpfile $sentence
	close $tmpfile
	return 0
}

###############################################
#### woerter zufällig aus den files suchen ####
###############################################

# returns:
# 0: es wurde was gesagt
# 1: nichts gesagt
# 2: auf nick durfte nicht geantwortet werden
# 3: satz nur ein wort lang, deshalb nicht reagiert
# 4: channel ist nicht zur antwort freigegeben

proc brain_readfiles { nick uhost hand chan arg } {
    global brain_brain_url brain_treffer b_sub b_subbb b_subbbb b_subbbbb add_chan dont_react_to
    
    if { ([lsearch -exact $dont_react_to $nick] >= 0)} {
		return 2
	}
    
    if {[llength [split $arg " "]] == "1"} { return 3 }
    
    if {([lsearch -exact $add_chan $chan] == -1) && ($add_chan != "*")} { return 4 }
    
    regsub -all -- \\\\ $arg \\\\\\\\ arg
    regsub -all -- \\\[ $arg \\\\\[ arg
    regsub -all -- \\\] $arg \\\\\] arg
    regsub -all -- \\\} $arg \\\\\} arg
    regsub -all -- \\\{ $arg \\\\\{ arg
    regsub -all -- \\\" $arg \\\\\" arg
    regsub -all -- Ä $arg Ae arg
    regsub -all -- Ü $arg Ue arg
    regsub -all -- Ö $arg Oe arg
    regsub -all -- ä $arg ae arg
    regsub -all -- ü $arg ue arg
    regsub -all -- ö $arg oe arg
    regsub -all -- ß $arg ss arg
    
    set sentence_in [join $arg]
    set brain_tmp_nr [rand [llength [split $arg " "]]]
    
    set x_zz 1
    while {$x_zz < 150} {
        incr x_zz
		set brain_tmp_nz [rand [llength [split $arg " "]]]
        if {($brain_tmp_nz != $brain_tmp_nr)} {
	    	break
		}
    }
    
    set x_yx 1
    while {$x_yx < 150} {
        incr x_yx
		set brain_tmp_nu [rand [llength [split $arg " "]]]
        if {($brain_tmp_nu != $brain_tmp_nr) && ($brain_tmp_nz != $brain_tmp_nu)} {
	    	break
		}
    }

    set brain_tmp [lindex $arg [rand 2]]
    set brain_tmp_zwo [lindex $arg $brain_tmp_nu]
    set brain_tmp_drei [lindex $arg $brain_tmp_nz]

    if {$brain_tmp == "ich"} { regsub  -- ich $brain_tmp du brain_tmp }
    if {$brain_tmp == "du"}  { regsub  -- du $brain_tmp ich brain_tmp }
    if {$brain_tmp == "ihr"} { regsub  -- ihr $brain_tmp ich brain_tmp }
    if {$brain_tmp == "wir"} { regsub  -- wir $brain_tmp ihr brain_tmp }
    
    if {$brain_tmp == "mir"} { regsub  -- mir $brain_tmp dir brain_tmp }
    if {$brain_tmp == "dir"} { regsub  -- dir $brain_tmp mir brain_tmp }
    if {$brain_tmp == "euch"} { regsub  -- euch $brain_tmp mir brain_tmp }
    if {$brain_tmp == "uns"} { regsub  -- uns $brain_tmp euch brain_tmp }
    
    if {$brain_tmp == "mein"} { regsub  -- mein $brain_tmp dein brain_tmp }
    if {$brain_tmp == "dein"} { regsub  -- dein $brain_tmp mein brain_tmp }
    if {$brain_tmp == "euer"} { regsub  -- euer $brain_tmp mein brain_tmp }
    if {$brain_tmp == "unser"} { regsub  -- unser $brain_tmp euer brain_tmp }
    
    if {$brain_tmp == "meinem"} { regsub  -- meinem $brain_tmp deinem brain_tmp }
    if {$brain_tmp == "deinem"} { regsub  -- deinem $brain_tmp meinem brain_tmp }
    if {$brain_tmp == "eurem"} { regsub  -- eurem $brain_tmp meinem brain_tmp }
    if {$brain_tmp == "unserm"} { regsub  -- unserm $brain_tmp eurem brain_tmp }
    if {$brain_tmp == "unserem"} { regsub  -- unserem $brain_tmp eurem brain_tmp }
    
    if {$brain_tmp == "meinen"} { regsub  -- meinen $brain_tmp deinen brain_tmp }
    if {$brain_tmp == "deinen"} { regsub  -- deinen $brain_tmp meinen brain_tmp }
    if {$brain_tmp == "euren"} { regsub  -- euren $brain_tmp meinen brain_tmp }
    if {$brain_tmp == "unsern"} { regsub  -- unsern $brain_tmp euren brain_tmp }
    if {$brain_tmp == "unseren"} { regsub  -- unseren $brain_tmp euren brain_tmp }
    
    if {$brain_tmp == "meiner"} { regsub  -- meiner $brain_tmp deiner brain_tmp }
    if {$brain_tmp == "deiner"} { regsub  -- deiner $brain_tmp meiner brain_tmp }
    
    if {$brain_tmp == "will"} { regsub  -- will $brain_tmp willst brain_tmp }
    if {$brain_tmp == "willst"} { regsub  -- willst $brain_tmp will brain_tmp }
    if {$brain_tmp == "wollt"} { regsub  -- wollt $brain_tmp will brain_tmp }
    if {$brain_tmp == "wollen"} { regsub  -- wollen $brain_tmp wollt brain_tmp }
    
    if {$brain_tmp == "habe"} { regsub  -- habe $brain_tmp hast brain_tmp }
	if {$brain_tmp == "hast"} { regsub  -- hast $brain_tmp hab brain_tmp }
    if {$brain_tmp == "habt"} { regsub  -- habt $brain_tmp hab brain_tmp }
    if {$brain_tmp == "haben"} { regsub  -- haben $brain_tmp habt brain_tmp }
    
    if {$brain_tmp == "bin"} { regsub  -- bin $brain_tmp bist brain_tmp }
	if {$brain_tmp == "bist"} { regsub  -- bist $brain_tmp bin brain_tmp }
    if {$brain_tmp == "seid"} { regsub  -- seid $brain_tmp bin brain_tmp }
    if {$brain_tmp == "sind"} { regsub  -- sind $brain_tmp seid brain_tmp }
    
    
    if {$brain_tmp_zwo == "ich"} { regsub  -- ich $brain_tmp_zwo du brain_tmp_zwo }
    if {$brain_tmp_zwo == "du"}  { regsub  -- du $brain_tmp_zwo ich brain_tmp_zwo }
    if {$brain_tmp_zwo == "ihr"} { regsub  -- ihr $brain_tmp_zwo ich brain_tmp_zwo }
    if {$brain_tmp_zwo == "wir"} { regsub  -- wir $brain_tmp_zwo ihr brain_tmp_zwo }
    
    if {$brain_tmp_zwo == "mir"} { regsub  -- mir $brain_tmp_zwo dir brain_tmp_zwo }
    if {$brain_tmp_zwo == "dir"} { regsub  -- mir $brain_tmp_zwo mir brain_tmp_zwo }
    if {$brain_tmp_zwo == "euch"} { regsub  -- euch $brain_tmp_zwo mir brain_tmp_zwo }
    if {$brain_tmp_zwo == "uns"} { regsub  -- uns $brain_tmp_zwo euch brain_tmp_zwo }
    
    if {$brain_tmp_zwo == "mein"} { regsub  -- mein $brain_tmp_zwo dein brain_tmp_zwo }
    if {$brain_tmp_zwo == "dein"} { regsub  -- dein $brain_tmp_zwo mein brain_tmp_zwo }
    if {$brain_tmp_zwo == "euer"} { regsub  -- euer $brain_tmp_zwo mein brain_tmp_zwo }
    if {$brain_tmp_zwo == "unser"} { regsub  -- unser $brain_tmp_zwo euer brain_tmp_zwo }
    
    if {$brain_tmp_zwo == "meinem"} { regsub  -- meinem $brain_tmp_zwo deinem brain_tmp_zwo }
    if {$brain_tmp_zwo == "deinem"} { regsub  -- deinem $brain_tmp_zwo meinem brain_tmp_zwo }
    if {$brain_tmp_zwo == "euren"} { regsub  -- euren $brain_tmp_zwo meinen brain_tmp_zwo }
    if {$brain_tmp_zwo == "unsern"} { regsub  -- unsern $brain_tmp_zwo euren brain_tmp_zwo }
    if {$brain_tmp_zwo == "unseren"} { regsub  -- unseren $brain_tmp_zwo euren brain_tmp_zwo }
    
    if {$brain_tmp_zwo == "meiner"} { regsub  -- meiner $brain_tmp_zwo deiner brain_tmp_zwo }
    if {$brain_tmp_zwo == "deiner"} { regsub  -- deiner $brain_tmp_zwo meiner brain_tmp_zwo }
    
    if {$brain_tmp_zwo == "will"} { regsub  -- will $brain_tmp_zwo willst brain_tmp_zwo }
    if {$brain_tmp_zwo == "willst"} { regsub  -- willst $brain_tmp_zwo will brain_tmp_zwo }
    if {$brain_tmp_zwo == "wollt"} { regsub  -- wollt $brain_tmp_zwo will brain_tmp_zwo }
    if {$brain_tmp_zwo == "wollen"} { regsub  -- wollen $brain_tmp_zwo wollt brain_tmp_zwo }
    

    if {$brain_tmp_drei == "ich"} { regsub  -- ich $brain_tmp_drei du brain_tmp_drei }
    if {$brain_tmp_drei == "du"}  { regsub  -- du $brain_tmp_drei ich brain_tmp_drei }
    if {$brain_tmp_drei == "ihr"} { regsub  -- ihr $brain_tmp_drei ich brain_tmp_drei }
    if {$brain_tmp_drei == "wir"} { regsub  -- wir $brain_tmp_drei ihr brain_tmp_drei }
    
    if {$brain_tmp_drei == "mir"} { regsub  -- mir $brain_tmp_drei dir brain_tmp_drei }
    if {$brain_tmp_drei == "dir"} { regsub  -- mir $brain_tmp_drei mir brain_tmp_drei }
    if {$brain_tmp_drei == "euch"} { regsub  -- euch $brain_tmp_drei mir brain_tmp_drei }
    if {$brain_tmp_drei == "uns"} { regsub  -- uns $brain_tmp_drei euch brain_tmp_drei }
    
    if {$brain_tmp_drei == "meinem"} { regsub  -- meinem $brain_tmp_drei deinem brain_tmp_drei }
    if {$brain_tmp_drei == "deinem"} { regsub  -- deinem $brain_tmp_drei meinem brain_tmp_drei }
    if {$brain_tmp_drei == "euren"} { regsub  -- euren $brain_tmp_drei meinen brain_tmp_drei }
    if {$brain_tmp_drei == "unsern"} { regsub  -- unsern $brain_tmp_drei euren brain_tmp_drei }
    if {$brain_tmp_drei == "unseren"} { regsub  -- unseren $brain_tmp_drei euren brain_tmp_drei }
    
    if {$brain_tmp_drei == "meiner"} { regsub  -- meiner $brain_tmp_drei deiner brain_tmp_drei }
	if {$brain_tmp_drei == "deiner"} { regsub  -- deiner $brain_tmp_drei meiner brain_tmp_drei }
    
    if {$brain_tmp_drei == "mein"} { regsub  -- mein $brain_tmp_drei dein brain_tmp_drei }
	if {$brain_tmp_drei == "dein"} { regsub  -- dein $brain_tmp_drei mein brain_tmp_drei }
	if {$brain_tmp_drei == "euer"} { regsub  -- euer $brain_tmp_drei mein brain_tmp_drei }
    if {$brain_tmp_drei == "unser"} { regsub  -- unser $brain_tmp_drei euer brain_tmp_drei }
    
    set tmpfile [open $brain_brain_url r]
    set output [split [read $tmpfile] "\r\n"]
    close $tmpfile
	set output_vurb [lindex $output [rand [llength $output]]]
    set x_xx 1
    set treffer_eins [expr $brain_treffer - $b_subbbbb]
    
    while {$x_xx < $treffer_eins} {
    	incr x_xx
    	set sentence_out [join $output_vurb]
       	if {([lsearch -exact $output_vurb $brain_tmp] >-1) 
	    	&& ([lsearch -exact $output_vurb $brain_tmp_zwo] >-1) 
	    	&& ([lsearch -exact $output_vurb $brain_tmp_drei] >-1)
	    	&& ([string compare $sentence_out $sentence_in] != 0)} {
	    		utimer [expr [llength $output_vurb]/2] [putserv "privmsg $chan :$sentence_out"]
				break
	    } else {
		    set output_vurb [lindex $output [rand [llength $output]]]
	    }
    }
    
    set x_xx 1
    set treffer_eins [expr $brain_treffer - $b_sub]
    
    while {$x_xx < $treffer_eins} {
    	incr x_xx
    	set sentence_out [join $output_vurb]
	    if {([lsearch $output_vurb $brain_tmp] >-1) 
	    	&& ([lsearch $output_vurb $brain_tmp_zwo] >-1)
	    	&& ([string compare $sentence_out $sentence_in] != 0)} {
	    		utimer [expr [llength $output_vurb]/2] [putserv "privmsg $chan :$sentence_out"]
				return 0
	    } else {
		    set output_vurb [lindex $output [rand [llength $output]]]
	    }
    }

    set z_rq 1
    set treffer_eins [expr $brain_treffer - $b_subbb]
    
    while {$z_rq < $treffer_eins} {
    	incr z_rq
    	set sentence_out [join $output_vurb]
	    if {([lsearch $output_vurb $brain_tmp] >-1) 
	    	&& ([lsearch $output_vurb $brain_tmp_drei] >-1)
	    	&& ([string compare $sentence_out $sentence_in] != 0)} {
				utimer [expr [llength $output_vurb]/2] [putserv "privmsg $chan :$sentence_out"]
				return 0
	    } else {
		    set output_vurb [lindex $output [rand [llength $output]]]
	    }
    }

    set y_rq 1
    set treffer_eins [expr $brain_treffer - $b_subbb]
    
    while {$y_rq < $treffer_eins} {
    	incr y_rq
	    set sentence_out [join $output_vurb]
	    if {([lsearch $output_vurb $brain_tmp_zwo] >-1) 
	    	&& ([lsearch $output_vurb $brain_tmp_drei] >-1)
	    	&& ([string compare $sentence_out $sentence_in] != 0)} {
				utimer [expr [llength $output_vurb]/2] [putserv "privmsg $chan :$sentence_out"]
				return 0
	    } else {
		    set output_vurb [lindex $output [rand [llength $output]]]
	    }
    }

    set y_rq 1
    set treffer_eins [expr $brain_treffer - $b_subbbb]
    
    while {$y_rq < $treffer_eins} {
    	incr y_rq
	    set sentence_out [join $output_vurb]
	    if {([lsearch $output_vurb $brain_tmp_zwo] >-1)
	    	&& ([string compare $sentence_out $sentence_in] != 0)} {
				utimer [expr [llength $output_vurb]/2] [putserv "privmsg $chan :$sentence_out"]
				return 0
	    } else {
	    	    set output_vurb [lindex $output [rand [llength $output]]]
	    }
    }

    set y_rq 1
    
    while {$y_rq < $treffer_eins} {
    	incr y_rq
	    set sentence_out [join $output_vurb]
	    if {([lsearch $output_vurb $brain_tmp_drei] >-1)
	    	&& ([string compare $sentence_out $sentence_in] != 0)} {
				utimer [expr [llength $output_vurb]/2] [putserv "privmsg $chan :$sentence_out"]
				return 0
	    } else {
		    set output_vurb [lindex $output [rand [llength $output]]]
	    }
    }
    
    set y_rq 1
    
    while {$y_rq < $treffer_eins} {
    	incr y_rq
	    set sentence_out [join $output_vurb]
	    if {([lsearch $output_vurb $brain_tmp] >-1)
	    	&& ([string compare $sentence_out $sentence_in] != 0)} {
				utimer [expr [llength $output_vurb]/2] [putserv "privmsg $chan :$sentence_out"]
				return 0
	    } else {
	    	    set output_vurb [lindex $output [rand [llength $output]]]
	    }
	}
    return 1
}

putlog "*** $botsnick's Gehirn erfolgreich initialisiert. *** (brain.tcl)"