This is the new home of the egghelp.org community forum.
All data has been migrated (including user logins/passwords) to a new phpBB version.


For more information, see this announcement post. Click the X in the top right-corner of this box to dismiss this message.

check blacklisted channels after 5 minutes after joining channel

Help for those learning Tcl or writing their own scripts.
Post Reply
s
simo
Revered One
Posts: 1130
Joined: Sun Mar 22, 2015 2:41 pm

check blacklisted channels after 5 minutes after joining channel

Post by simo »

greetings ,

the idea is to store each nick on join in a list after a check for not being admin ops halfops and such than to add in a list to send to a proc to do whois (in stacks of 20) on all the stored nicks after like 5 minutes to check for blacklisted channels and clear all checked nicks from the stored list im not sure i'm on the right track with this code :

Code: Select all


namespace eval checkbadchan {

bind join - * [namespace current]::Djoin:badChnz:Checker

 	setudef flag chckbadchan

 if {[string match "*BadChan:Scan*" [utimers]] == 0} {
    utimer 5 [namespace current]::BadChan:Scan
  }


proc Djoin:badChnz:Checker {nick uhost hand chan} {
  global chkbchan
      if {![channel get $chan chckbadchan]} { return 0 }
    if {[isbotnick $nick] || [matchattr $hand of|of $chan]} { return 0 }
     after [expr {2*1000*1}] [list [namespace current]::Delay-join:badChnz:Chk $nick $uhost $chan] 
}
 

proc Delay-join:badChnz:Chk  {nick uhost chan} {
  global chkbchan
     set ::badchanwhois [list]
    if {![channel get $chan chckbadchan]} { return 0 }
    if {[isbotnick $nick] || [isop $nick $chan] || [ishalfop $nick $chan] || [matchattr [nick2hand $nick] of|of $chan]} { return 0 }
        if {[lsearch -exact $::badchanwhois "[string tolower $nick] $chan"] == -1} { lappend ::badchanwhois [string tolower $nick] $chan  }
}
 

proc BadChan:Scan { } {
   
 set badwhoisonchan [list]

 if {[string match "*BadChan:Scan*" [utimers]] == 0} {
    utimer 5 [namespace current]::BadChan:Scan
  }

 

   if {![info exists ::badchanwhois]} { return 0 }
    

  foreach {nick chan} $::badchanwhois {
    if {[onchan $nick $chan] } { lappend badwhoisonchan [string tolower $nick]   }
      }

     if {[info exists badwhoisonchan]} {  [namespace current]::Stck:WHoiZ $chan $badwhoisonchan  }


}





	proc Stck:WHoiZ {chan userList {max 20}} {
       set ::chanxer $chan
         set userList [lsort -unique $userList]
		set count [llength $userList]
     	set counter 0
		while {$count > 0} {
			if {$count > $max} {
				set users [join [lrange $userList 0 [expr {$max - 1}]] ","]
				set userList [lreplace $userList 0 [expr {$max -1}]]
				incr count -$max
			} else {
				set users [join $userList ","]
				set count 0
			}
               incr counter 1
               after [expr {$counter*5000}] [list  putserv "Whois :$users"] 
		}
               bind raw - 319 [namespace current]::Check_BChanz
	}

 


proc Check_BChanz {from key arg} {
	global listbadchans
	set chans [list]
	set args [join $arg]
	set nick [lindex $arg 1]
	if {[onchan $nick $::chanxer]} { set chost [getchanhost $nick $::chanxer] }
	set badchans [list]
	set chans [lrange $args 2 e]
	foreach tok $chans {
		set tok [string trimleft $tok ":@%+"]
         if {[regexp -nocase {slut|bdsm|s[0o]d[0o]m|daughter|wh[0o]r[3e]|subm[i1]ss[1i]v[3e]|s[3e]ks|s[3e]cs|tits|pr[3e]gn[4a]t[1i]|pregnant|Rape|r[0o]l[3e]pl[a4]y|ambition|s[3e]ks|g[a4]y|[sf][4u]ck|inc[3e]st|s[3e]x|th[i1]rsty|c[4u]m|t[3e][3e]nw[a4]nk[i1]n|h[0o]m[0o|se(x|ks)|(s|f)uck|p(orn|0rn|enis)|h[0o]rny} $tok]} {  
			lappend badchans $tok
		}
	}
    if {[llength $badchans]} {
              putlog "Bad Channel Detected For $nick - [join $badchans]" 
   if {[string match -nocase "*@*irccloud*" $chost]} { 
                    set ident [string trimleft [lindex [split $chost @] 0] "~"]
                    set xbmaskx [string map {sid id uid id} $ident]
                    set bmask  *!*[string tolower $xbmaskx ]@*
        } else { set bmask "*!*@[lindex [split $chost "@"] 1]" } 
             if {![ischanban $bmask $::chanxer]} { pushmode $::chanxer +b $bmask } 
           if {[onchan $nick $::chanxer]} { 
              putserv "privmsg $nick :\00312,00 $nick \00301 You Are In An Unallowed Channel\(S\)\: \00306 \037[join $badchans]\037 \00301 Part It/Them And Rejoin \00310 \037$::chanxer\037 \00301 Later After Your Ban Has Expired \017" 
              putserv "kick $::chanxer $nick :\002\00312,00 «-BAD/BlackListed & OR Spam CHANNEL DETECTED-» \017" }
}
	return 0
}
}

    putlog "[file normalize [info script]]"

ive tested it a few times and it doesnt seem to get all the nicks to boot out if they are in a blacklisted channel.


Thanks in advance.
Last edited by simo on Sun Dec 07, 2025 11:01 am, edited 1 time in total.
p
pektek
Halfop
Posts: 76
Joined: Sat Jul 01, 2023 4:51 pm
Location: TURKEY
Contact:

Re: check blacklisted channels after 5 minutes after joining channel

Post by pektek »

corrected version

Code: Select all

namespace eval checkbadchan {

    bind join - * [namespace current]::Djoin:badChnz:Checker
    setudef flag chckbadchan

    if {[string match "*BadChan:Scan*" [utimers]] == 0} {
        utimer 5 [namespace current]::BadChan:Scan
    }

    proc Djoin:badChnz:Checker {nick uhost hand chan} {
        if {![channel get $chan chckbadchan]} { return 0 }
        if {[isbotnick $nick] || [matchattr $hand of|of $chan]} { return 0 }
        after 2000 [list [namespace current]::Delay-join:badChnz:Chk $nick $uhost $chan]
    }

    proc Delay-join:badChnz:Chk {nick uhost chan} {
        if {![channel get $chan chckbadchan]} { return 0 }
        if {[isbotnick $nick] || [isop $nick $chan] || [ishalfop $nick $chan] || [matchattr [nick2hand $nick] of|of $chan]} { return 0 }
        
        if {![info exists ::badchanwhois]} { set ::badchanwhois [list] }

        if {[lsearch -exact $::badchanwhois "[string tolower $nick] $chan"] == -1} {
            lappend ::badchanwhois [string tolower $nick] $chan
        }
    }

    proc BadChan:Scan {} {
        set badwhoisonchan [list]

        if {[string match "*BadChan:Scan*" [utimers]] == 0} {
            utimer 5 [namespace current]::BadChan:Scan
        }

        if {![info exists ::badchanwhois]} { return 0 }

        foreach {nick chan} $::badchanwhois {
            if {[onchan $nick $chan]} {
                lappend badwhoisonchan [string tolower $nick]
            }
        }

        if {[info exists badwhoisonchan]} {
            [namespace current]::Stck:WHoiZ $chan $badwhoisonchan
        }
    }

    proc Stck:WHoiZ {chan userList {max 20}} {
        set ::chanxer $chan
        set userList [lsort -unique $userList]
        set count [llength $userList]
        set counter 0

        while {$count > 0} {
            if {$count > $max} {
                set users [join [lrange $userList 0 [expr {$max - 1}]] ","]
                set userList [lreplace $userList 0 [expr {$max - 1}]]
                incr count -$max
            } else {
                set users [join $userList ","]
                set count 0
            }
            incr counter 1
            after [expr {$counter * 5000}] [list putserv "Whois :$users"]
        }
        bind raw - 319 [namespace current]::Check_BChanz
    }

    proc Check_BChanz {from key arg} {
        set args [join $arg]
        set nick [lindex $arg 1]

        if {[onchan $nick $::chanxer]} {
            set chost [getchanhost $nick $::chanxer]
        }

        set chans [lrange $args 2 end]
        set badchans [list]

        # ------------------- BANLANACAK KELIME/KANAL REGEX -------------------
        if {[regexp -nocase {
            slut|bdsm|s[0o]d[0o]m|daughter|wh[0o]r[3e]|subm[i1]ss[1i]v[3e]|
            s[3e]ks|s[3e]cs|tits|pr[3e]gn[4a]t[1i]|pregnant|rape|r[0o]l[3e]pl[a4]y|
            ambition|g[a4]y|[sf][4u]ck|inc[3e]st|s[3e]x|th[i1]rsty|c[4u]m|
            t[3e][3e]nw[a4]nk[i1]n|(s|f)uck|p(orn|0rn|enis)|h[0o]rny|
            h[0o]m[0o]se(x|ks)
        } $args]} {
            lappend badchans $args
        }
        # ----------------------------------------------------------------------

        if {[llength $badchans]} {

            putlog "⚠ Bad Channel Detected → $nick | [join $badchans]"

            # IRCCloud kullanıcı maskesi
            if {[string match -nocase "*@*irccloud*" $chost]} {
                set ident [string trimleft [lindex [split $chost @] 0] "~"]
                set xbmaskx [string map {sid id uid id} $ident]
                set bmask *!*[string tolower $xbmaskx]@*
            } else {
                set bmask "*!*@[lindex [split $chost "@"] 1]"
            }

            if {![ischanban $bmask $::chanxer]} {
                pushmode $::chanxer +b $bmask
            }

            if {[onchan $nick $::chanxer]} {
                putserv "privmsg $nick :\00312$nick\00301 Yasaklı/Blacklisted Kanal Tespit Edildi → \00304[join $badchans]\003"
                putserv "kick $::chanxer $nick :\00304« BAD / BLACKLISTED SPAM CHANNEL »\017"
            }
        }
        return 0
    }
}

putlog "Loaded → [file normalize [info script]]"
s
simo
Revered One
Posts: 1130
Joined: Sun Mar 22, 2015 2:41 pm

Re: check blacklisted channels after 5 minutes after joining channel

Post by simo »

thanks for your reply

Ive tested it and got this error :
Tcl error [::checkbadchan::Check_BChanz]: can't read "chost": no such variable
s
simo
Revered One
Posts: 1130
Joined: Sun Mar 22, 2015 2:41 pm

Re: check blacklisted channels after 5 minutes after joining channel

Post by simo »

also the timer doesnt get cleared
after#858 = {putserv {Whois :alard,circosta,consuela,dragone,fanya,ioab,nakasuji,pavlov,sisson,tremayne}} timer
p
pektek
Halfop
Posts: 76
Joined: Sat Jul 01, 2023 4:51 pm
Location: TURKEY
Contact:

Re: check blacklisted channels after 5 minutes after joining channel

Post by pektek »

try this ;

If there is a mistake, just tell me, my friend.

Code: Select all

namespace eval checkbadchan {

    bind join - * [namespace current]::Djoin:badChnz:Checker
    setudef flag chckbadchan

    if {[string match "*BadChan:Scan*" [utimers]] == 0} {
        utimer 5 [namespace current]::BadChan:Scan
    }

    proc Djoin:badChnz:Checker {nick uhost hand chan} {
        if {![channel get $chan chckbadchan]} { return 0 }
        if {[isbotnick $nick] || [matchattr $hand of|of $chan]} { return 0 }
        after 2000 [list [namespace current]::Delay-join:badChnz:Chk $nick $uhost $chan]
    }

    proc Delay-join:badChnz:Chk {nick uhost chan} {
        if {![channel get $chan chckbadchan]} { return 0 }
        if {[isbotnick $nick] || [isop $nick $chan] || [ishalfop $nick $chan] || [matchattr [nick2hand $nick] of|of $chan]} { return 0 }

        if {![info exists ::badchanwhois]} { set ::badchanwhois [list] }

        if {[lsearch -exact $::badchanwhois "[string tolower $nick] $chan"] == -1} {
            lappend ::badchanwhois [string tolower $nick] $chan
        }
    }

    proc BadChan:Scan {} {
        set badwhoisonchan [list]

        if {[string match "*BadChan:Scan*" [utimers]] == 0} {
            utimer 5 [namespace current]::BadChan:Scan
        }

        if {![info exists ::badchanwhois]} { return 0 }

        foreach {nick chan} $::badchanwhois {
            if {[onchan $nick $chan]} {
                lappend badwhoisonchan [string tolower $nick]
            }
        }

        if {[llength $badwhoisonchan]} {
            [namespace current]::Stck:WHoiZ $chan $badwhoisonchan
        }
    }

    proc Stck:WHoiZ {chan userList {max 20}} {
        set ::chanxer $chan
        set userList [lsort -unique $userList]
        set count [llength $userList]
        set counter 0

        while {$count > 0} {
            if ($count > $max) {
                set users [join [lrange $userList 0 [expr {$max - 1}]] ","]
                set userList [lreplace $userList 0 [expr {$max - 1}]]
                incr count -$max
            } else {
                set users [join $userList ","]
                set count 0
            }
            incr counter 1
            after [expr {$counter * 5000}] [list putserv "Whois :$users"]
        }
        bind raw - 319 [namespace current]::Check_BChanz
    }

    proc Check_BChanz {from key arg} {
        set args [join $arg]
        set nick [lindex $arg 1]

        # Hata engellemek için default host
        set chost ""

        # Kullanıcı kanalda ise host’u al
        if {[onchan $nick $::chanxer]} {
            set chost [getchanhost $nick $::chanxer]
        }

        # Host yine boşsa işlem yapma — hata engelliyoruz
        if {$chost eq ""} {
            return 0
        }

        set badchans [list]

        # ------------------ KARA LİSTE REGEX ------------------
        if {[regexp -nocase {
            slut|bdsm|s[0o]d[0o]m|daughter|wh[0o]r[3e]|subm[i1]ss[1i]v[3e]|
            s[3e]ks|s[3e]cs|tits|pr[3e]gn[4a]t[1i]|pregnant|rape|r[0o]l[3e]pl[a4]y|
            ambition|g[a4]y|[sf][4u]ck|inc[3e]st|s[3e]x|th[i1]rsty|c[4u]m|
            t[3e][3e]nw[a4]nk[i1]n|(s|f)uck|p(orn|0rn|enis)|h[0o]rny|
            h[0o]m[0o]se(x|ks)
        } $args]} {
            lappend badchans $args
        }
        # -------------------------------------------------------

        if {[llength $badchans]} {

            putlog "Bad Channel Detected → $nick | [join $badchans]"

            # IRCCloud mask fix
            if {[string match -nocase "*@*irccloud*" $chost]} {
                set ident [string trimleft [lindex [split $chost @] 0] "~"]
                set xbmaskx [string map {sid id uid id} $ident]
                set bmask *!*[string tolower $xbmaskx]@*
            } else {
                set bmask "*!*@[lindex [split $chost @] 1]"
            }

            if {![ischanban $bmask $::chanxer]} {
                pushmode $::chanxer +b $bmask
            }

            if {[onchan $nick $::chanxer]} {
                putserv "privmsg $nick :\00312$nick\00301 Yasaklı / Blacklisted Kanal Tespit Edildi → \00304[join $badchans]\003"
                putserv "kick $::chanxer $nick :\00304« BAD / BLACKLISTED SPAM CHANNEL »\017"
            }
        }
        return 0
    }
}

putlog "Loaded → [file normalize [info script]]"   
s
simo
Revered One
Posts: 1130
Joined: Sun Mar 22, 2015 2:41 pm

Re: check blacklisted channels after 5 minutes after joining channel

Post by simo »

Ive tried this version and it returns lot of errors, but this code seems generated by AI, did you write this code?
p
pektek
Halfop
Posts: 76
Joined: Sat Jul 01, 2023 4:51 pm
Location: TURKEY
Contact:

Re: check blacklisted channels after 5 minutes after joining channel

Post by pektek »

# NOTE:
# Your Eggdrop bot MUST be inside the channels you want to monitor.
# Otherwise the scanner will NOT work.
# Tested and working. — Pektek
# Please respect the time and effort put into this.

# Just run it, sit down, and watch, Simo

Code: Select all

namespace eval checkbadchan {

    # JOIN trigger
    bind join - * checkbadchan::checkbadchan:scan

    # Main scan procedure
    proc checkbadchan:scan {nick uhost hand chan} {

        # Skip bot, op, halfop
        if {[isbotnick $nick] || [matchattr $hand of|of $chan]} {
            return 0
        }

        # Convert channel name to lowercase
        set lc [string tolower $chan]

        # Blacklisted channel keywords
        set regex {.*(sex|sexy|sexchat|seks|porno|porn|pornstar|gay|gey|[censored]|fck|fuk|dick|diq|cum|cumm|horny|bdsm|slut|whore|tits|milf).*}

        # If match found
        if {[regexp -nocase $regex $lc]} {

            putlog "BADCHAN → $nick joined $chan (MATCH)"

            # Create ban mask
            set hostmask "*!*@[lindex [split $uhost @] 1]"

            # Add ban if not already banned
            if {![ischanban $hostmask $chan]} {
                pushmode $chan +b $hostmask
            }

            # Send private message
            putserv "PRIVMSG $nick :Warning: Blacklisted channel detected -> $chan"

            # Kick user
            putserv "KICK $chan $nick :BLACKLISTED CHANNEL"

            return 0
        }

        return 0
    }
}
putlog "Loaded by Pektek"
I’m giving you three versions, both tested and working. I spent hours on this for you, Simo.
Respectfully, Pektek.

NOTE: What this TCL does (short & clear):
!add #channel → Adds the channel to the blacklist, saves it to .badchan and channels.conf.
Bot automatically JOINs the channel using OS RAW JOIN.

When the bot joins the channel, it takes +o, and after 2 seconds it scans everyone inside.

If the bot is in the channel, anyone who joins is banned + kicked after 5 seconds.

Even if the user is OP / founder / admin, they still get ban + kick.

Bot stays in the channel for 2 minutes, then sends PART and leaves.

After a bot restart, .badchan is loaded and the bot rejoins all blacklisted channels and continues working automatically.
Please move the bot you want to operate to an authorized channel and add it to the channel using !add #channel.

Just run it, sit down, and watch, Simo 8)

Code: Select all

namespace eval badchan {
    variable list {}
    variable file ".badchan"

    ###################################################
    # LOAD CHANNEL LIST (ON RESTART)
    ###################################################
    proc load_list {} {
        variable list
        variable file

        if {[file exists $file]} {
            set fp [open $file r]
            set data [split [read $fp] "\n"]
            close $fp
            foreach chan $data {
                if {$chan ne ""} {
                    lappend list $chan
                }
            }
            putlog "BADCHAN → Loaded [llength $list] channels from file."
        } else {
            putlog "BADCHAN → .badchan file not found, creating new list."
        }
    }

    ###################################################
    # SAVE CHANNEL LIST TO FILE
    ###################################################
    proc save_list {} {
        variable list
        variable file

        set fp [open $file w]
        foreach chan $list { puts $fp $chan }
        close $fp

        putlog "BADCHAN -> Channel list saved to file."
    }

    ###################################################
    # APPEND CHANNEL TO channels.conf
    ###################################################
    proc save_conf {chan} {
        set fp [open "channels.conf" a]
        puts $fp "channel add $chan {\n    auto-join 1\n}"
        close $fp

        putlog "BADCHAN -> $chan added to channels.conf."
    }

    ###################################################
    # COMMAND: !add #channel
    ###################################################
    bind pub n|n !add ::badchan::cmd_add

    proc cmd_add {nick uhost hand chan args} {
        variable list
        set target [string tolower [lindex $args 0]]

        if {$target eq "" || [string index $target 0] ne "#"} {
            putserv "PRIVMSG $chan :Usage: !add #channel"
            return
        }

        if {[lsearch -exact $list $target] != -1} {
            putserv "PRIVMSG $chan :$target is already in the blacklist."
            return
        }

        # Add to internal list + save
        lappend list $target
        save_list
        save_conf $target

        putserv "PRIVMSG $chan :$target has been added to the BADCHAN blacklist."
        putlog "BADCHAN → Added $target to blacklist."

        # Register channel in Eggdrop
        channel add $target
        channel set $target +auto-join
        channel set $target -inactive

        # RAW JOIN through OS (guaranteed join)
        utimer 2 "putserv \"PRIVMSG OS :RAW :$::botnick JOIN $target\""

        putlog "BADCHAN → RAW JOIN sent for $target."
    }

    ###################################################
    # SCAN CHANNEL (If bot joins late)
    ###################################################
    proc scan_channel {chan} {
        set users [chanlist $chan]
        foreach u $users {
            if {![string equal -nocase $u $::botnick]} {
                set host [getchanhost $u $chan]
                ::badchan::punish $chan $u $host
            }
        }
        putlog "BADCHAN → Completed scan for $chan (all users punished)."
    }

    ###################################################
    # JOIN EVENT HANDLER
    ###################################################
    bind join - * ::badchan::on_join

    proc on_join {nick uhost hand chan} {
        variable list
        set chan [string tolower $chan]

        # If channel not in blacklist → do nothing
        if {[lsearch -exact $list $chan] == -1} return

        # BOT JOINS
        if {[string equal -nocase $nick $::botnick]} {

            # Bot gets OP
            utimer 1 "putserv \"MODE $chan +o $::botnick\""
            putlog "BADCHAN -> Bot joined $chan and received +o."

            # Scan the channel (punish all users)
            utimer 2 [list ::badchan::scan_channel $chan]

            # Leave after 2 minutes
            utimer 120 "putserv \"PART $chan :Leaving…\""

            return
        }

        # USER JOINS → punish after 5 seconds
        utimer 5 [list ::badchan::punish $chan $nick $uhost]
    }

    ###################################################
    # PUNISHMENT SYSTEM (BAN + KICK)
    ###################################################
    proc punish {chan nick uhost} {

        putlog "BADCHAN → Punishing $nick in $chan."

        # Ensure bot has OP
        if {![isop $::botnick $chan]} {
            putserv "MODE $chan +o $::botnick"
            after 300
        }

        # Create ban mask
        set hostpart [lindex [split $uhost @] 1]
        set mask "*!*@$hostpart"

        # Ban + kick user
        putserv "MODE $chan +b $mask"
        putserv "KICK $chan $nick :Blacklisted channel."

        putlog "BADCHAN → $nick was banned and kicked from $chan."
    }

    ###################################################
    # AUTO-JOIN BLACKLISTED CHANNELS AFTER RESTART
    ###################################################
    bind evnt - init-server ::badchan::startup

    proc startup {type} {
        variable list
        ::badchan::load_list

        foreach chan $list {

            channel add $chan
            channel set $chan +auto-join
            channel set $chan -inactive

            # RAW JOIN through OS
            utimer 3 "putserv \"PRIVMSG OS :RAW :$::botnick JOIN $chan\""

            putlog "BADCHAN → RAW JOIN sent for $chan after restart."
        }
    }
}

putlog "Loaded Badchan by pektek"                       
Please respect the time and effort put into this. 8)

If you want to prevent anyone from joining channels except their autojoin channels, the easiest way is to add the following code inside unrealircd.conf:
After adding this, save the file and run /rehash on the server, or execute ./unreal rehash in telnet.

From now on, no user will be able to join any channel manually.
This is the third version of this method.

Code: Select all

deny channel {
channel "#*";
reason "Opening channels on the server is FORBIDDEN!";
warn on;
};
allow channel {
    channel "#Connection";
};
allow channel {
    channel "#DJ";
};
allow channel {
    channel "#DJChat";
};
allow channel {
    channel "#Help";
};
allow channel {
    channel "#WordGame";
};
allow channel {
    channel "#Number";
};
When you set the channel names as autojoin, no one will be allowed to join any channels other than the ones you specify.
No user will be able to randomly join any channels; they will be blocked.
These are only examples — the important point is that the channel names you define for autojoin must be the same as the channel names you write here.
This added command is valid and tested for the Unreal 3.2.x series. It has not been tested on other versions.
s
simo
Revered One
Posts: 1130
Joined: Sun Mar 22, 2015 2:41 pm

Re: check blacklisted channels after 5 minutes after joining channel

Post by simo »

thanks for your reply pektek but it seems all 3 methods you posted dont meet the criteria ive mentioned in my first post and also i dont need anything unrealircd related as this is used on dalnet, but i apreciate your attempt to contribute to a solution, this is much apreciated as always ofcourse.
p
pektek
Halfop
Posts: 76
Joined: Sat Jul 01, 2023 4:51 pm
Location: TURKEY
Contact:

Re: check blacklisted channels after 5 minutes after joining channel

Post by pektek »

I don’t really know much about DALnet. This bot is based on Unreal 3.2. If you switch to Unreal, you can easily use what I shared with you. There are no errors; I carefully tested everything before sharing it. Thanks a lot for your interest, Simo. If you ever have any questions about an Unreal 3.2 Eggdrop, feel free to ask; I can test it for you and share a clean, trouble-free version anytime 8)
Post Reply