BOT PARLANT

Commentaire de TropNul le 24/10/2007 16:45:11

lol, je suis sur que bon nombre de personnes tomberont dans le panneau et parleront a ce bot pendant un moment avant de se rendre compte du truc.

a l'etat ou est le code, il y subsiste une faille importante. a savoir que sur un salon avec plusieurs personnes, il y aura de fortes chances qu'il soit deconnecter en 'excess flood'. donc, a revoir le systeme de 'timer msg ...' (peut-etre dans une queue de messagerie).

a part ca, bon courage pour l'amelioration.

Commentaire de wims le 25/10/2007 19:45:19

Faire 3 write sur un on text ça va faire ramer mémée ? sur un de mes vieux pc 266mhz ouais, mais pas sur les pc d'aujourd'hui...

Sur un fichier de plus de 700 lignes, je met 0 ms (15 max) a écrire trois fois dans le fichier,et le pc sur lequel je fais ça est vraiment bof :)

Commentaire de ISoKa le 26/10/2007 03:33:14

je démord pas que franchement le write en 3 fois c grave pas joli et optimal :) moi je voi sur des remotes que je fai quand j'ai trop de write en meme temps je le sent passer. pour ce qui est des htables bin suffit au lieu de write de faire hadd et ensuite pour la recherche un $find ou $hmatch et ca se fai gentiment.

Commentaire de TropNul le 26/10/2007 15:24:53

ERRATA:

[1]
...dans le cas ou le prochain temps du timermsg est superieur au temps du timermsg precedent...

a remplacer par:

...dans le cas ou le prochain temps du timermsg est inferieur au temps du timermsg precedent...

[2]
timerUn 1 5 echo -at je ne salue pas :p

a remplacer par:

timerUn 1 5 echo -at je ne te salue pas :p

^^

Commentaire de TropNul le 26/10/2007 18:26:26

Tant que j'y suis, je continue.

[REMARQUE1]
Il faudrait aussi que tu prevois un systeme de remise a zero ou de stockage efficace du fichier text.txt. En effet, sa taille ne cessera de s'agrandir avec le present code.
[/REMARQUE1]

[REMARQUE2]
Ce qu'isoka a fait ressortir n'est pas denue de sens. D'apres mes tests personnels d'il y a quelques temps, a partir de 7000 lignes dans un fichier txt et quand on n'utilise pas les moyens misent a diposition par mirc pour ce genre de cas, tu risques d'avoir des petits intervalles de 'freeze' de mirc. Mais c'est assez insignifiant si tu ne fais que trois write. Donc, dans le cas ou tu changerais la facon d'acceder a ce fichier ou alors si tu changes ton algorithme de recherche, et surtout, s'il t'arrives a inclure ne serait-ce qu'une seule boucle while, utilises le file handling ou des hash tables. Ce sera nettement mieux et aussi beau a voir :p.
[/REMARQUE2]

[REMARQUE3]
L'identifieur $rand peut etre remplace par $r.
[/REMARQUE3]

[REMARQUE4]
La condition

if ( $1 isin %msg || $2 isin %msg || $3 isin %msg || $4 isin %msg || $5 isin %msg || $6 isin %msg ) { timermsg 1 $rand(2,5) msg $chan %msg }

peut etre optimise par

if $regex($1-,/( $+ $replace(%msg,$chr(32),$chr(124)) $+ )/i) { timermsg 1 $r(2,5) msg $chan %msg }

alors, oui, j'ai change son fonctionnement pour faire en sorte de verifier tous les mots dits par $nick. je pense que c'est mieux. mais evidemment, tu peux remplacer $1- par $1-6.
[/REMARQUE4]

[REMARQUE5]
La methode dont tu as use pour le goto me laisse perplexe. Une boucle while serait plus 'propre' a mon avis.
Voila ce que je propose:

On *:Text:*:#:{
  Var %repeat = 0
  While (%repeat <= 1000) {
    If ($r(1,2) == 1) { Set %msg $read(text.txt) }
    ElseIf ($r(1,5) == 1) { Set %msg $read(text.txt) $read(text.txt) $read(text.txt) }
    Else { Set %msg $read(text.txt) $read(text.txt) }
    If $regex($1-,/( $+ $replace(%msg,$chr(32),$chr(124)) $+ )/i) { Timermsg 1 $r(2,5) Msg $chan %msg }
    Inc %repeat
  }
  If $6 { Write text.txt $5 $6 }
  ElseIf $4 {
    Write text.txt $3 $4
    Write text.txt $1 $2 $3 $4
  }
  ElseIf $2 { Write text.txt $1 $2 }
  If ($r(1,100) == 5) { Write text.txt $nick }
  UnSet %repeat
}
[/REMARQUE5]

Si j'ai d'autres remarques/propositions, je le ferais :)

Cordialement

Commentaire de wims le 27/10/2007 00:59:05

met un $+, ça marchera mieux (3e ligne)

Commentaire de ISoKa le 27/10/2007 13:21:12

Tropnul en lisant le code que tu as fai je voi :
  While (%repeat <= 1000) {
    If ($r(1,2) == 1) { Set %msg $read(text.txt) }
    ElseIf ($r(1,5) == 1) { Set %msg $read(text.txt) $read(text.txt) $read(text.txt) }
    Else { Set %msg $read(text.txt) $read(text.txt) }
    If $regex($1-,/( $+ $replace(%msg,$chr(32),$chr(124)) $+ )/i) { Timermsg 1 $r(2,5) Msg $chan %msg }
    Inc %repeat
  }

pense peut etre à break si ton regex match pck si jamais y a bcp d'occurences dans le txt tu vas excess flood je pense. le code original avec ses if et elseif break de facon virtuelle.

Commentaire de TropNul le 27/10/2007 14:24:14

Mea Culpa.

Tu avais raison isoka ;). Son code ne le fait pas 'virtuellement' mais bien concretement. Ah, le pouvoir du elseif ...

Soit, mon code devient donc:

On *:Text:*:#:{
  Var %repeat = 0
  While (%repeat <= 1000) {
    If ($r(1,2) == 1) { Set %msg $read(text.txt) }
    ElseIf ($r(1,5) == 1) { Set %msg $read(text.txt) $read(text.txt) $read(text.txt) }
    Else { Set %msg $read(text.txt) $read(text.txt) }
    If $regex($1-,/( $+ $replace(%msg,$chr(32),$chr(124)) $+ )/i) {
      Timermsg 1 $r(2,5) Msg $chan %msg
      ;thx isoka ^^
      Break
    }
    Inc %repeat
  }
  If $6 { Write text.txt $5 $6 }
  ElseIf $4 {
    Write text.txt $3 $4
    Write text.txt $1 $2 $3 $4
  }
  ElseIf $2 { Write text.txt $1 $2 }
  If ($r(1,100) == 5) { Write text.txt $nick }
  UnSet %repeat
}

Commentaire de wims le 27/10/2007 15:46:43

On *:Text:*:#:{
  Var %a 1 ,%r $+($!read(text.txt),$chr(32))
  While (%repeat <= 1000) {
  var %m $str($(%r,2),$iif(!$r(0,1),1,$iif(!$r(0,4),3,2)))
  var %p $+(/(,$replace(%m,$chr(32),$chr(124)),)/i)
  If $regex($1-,%p) { Timermsg 1 $r(2,5) Msg $chan %m | Break }
  Inc %repeat
  }
  var %w $+($iif($6,$5-6,$iif($4,$+($3-4,$crlf,$1-4),$iif($2,$1-2))))
  Write text.txt %w
  If (!$r(0,99)) Write text.txt $nick
}


C'est peut-être pas la meilleur optimisation car c'est surement plus long, et c'est un peu moche, mais ça montre des techniques a utiliser lorsque certaine action se ressemble un peu trop et qu'on ne sais pas comment amélioré ça :)

Commentaire de wims le 27/10/2007 18:02:42

Le ! permet de retourné la forme non évalué d'un identifier/variable, du style :

//echo -a $!me $!!me
Combiné avec $() ( $eval() quoi ) :
//echo -a $($!!me,3)
;$me est la forme évalué 0 fois
;la valeur de $me est la formé évalué 1 fois ...
;$!me c'est -1
;donc là, $!!me c'est -2, on évalue 3 fois , -2 + 3 = 1 on retrouve bien la valeur de $me évalué une fois.

En gros dans le code, je stock la valeur non évalué de $read(text.txt) dans une variable parce que on va utiliser plusieur fois ce $read et la valeur doit etre actualisé a chaque fois qu'on l'utilise, si on mettais que $read(text.txt), la valeur serait tjs la même.J'utilise ensuite $(,2) pour actualisé a chaque coup :]

Commentaire de Drummond le 02/01/2008 13:43:06

super