Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

BELOTE (MULTIJOUEURS) EN PICWIN


Information sur la source

Catégorie :AddOns Classé sous : belote, multijoueurs, picwin, jeu, cartes Niveau : Initié Date de création : 01/09/2007 Date de mise à jour : 03/09/2007 01:00:25 Vu / téléchargé: 10 389 / 111

Note :
10 / 10 - par 3 personnes
10,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10

Commentaire sur cette source (19)
Ajouter un commentaire et/ou une note

Description

Cliquez pour voir la capture en taille normale
Voici un jeu de Belote se jouant à quatre sur internet. Normalement très simple d'installation, il faut toutefois avoir un port débloqué pour compter espérer créer une partie.
Il n'y a pas d'IA pour le moment donc si vous manquez de joueurs venez vous rencontrer sur mon salon :
/server -m irc.quakenet.org:6667 -j #arkanis

Tapez /belote pour procéder au téléchargement des fichiers et pour ouvrir la PicWin.

Liste des fonctions et particularités :
- Fenêtre de conversation munie d'un ascenseur
- Possibilité d'avoir deux spectateurs (six joueurs dans la partie)
- Possibilité d'exclure un joueur/spectateur au cours de la partie
- Possibilité de remplacer un joueur par un spectateur au cours de la partie, qu'il ait été banni, en train de jouer ou déconnecté
- Votre jeu s'affichera toujours en bas, votre coéquipier est en haut
- Facile d'installation et de désinstallation
- Utilise le fichier GUI-ArKanis.mrc (téléchargé et chargé automatiquement)
- Aide incluse dans la PicWin
- Tour de jouer représenté par un carré vert
- Rappel des points, liste des joueurs, score, ... affichés sur la fenêtre de jeu
- On peut choisir les équipes mais si aucune n'est spécifiée, elles sont faites par ordre de connexion
- Si votre résolution d'écran est trop petite, les cartes ne seront pas dessinées mais un système est prévu pour y remédier
- Possibilité de voir le dernier pli réalisé

Concernant le jeu :
- Annonces belote/rebelote activées
- Distribution des cartes sans mélanger (permet d'avoir de meilleurs jeux)
- Fonctionne avec 90% des règles (trop de variantes ...)
- Valet forcé (si un valet est retourné, le suivant est obligé de prendre)
- Si le coéquipier est maître (hors-atout), vous n'êtes pas obligé de couper

Que dire de plus sinon que ... essayez-la :)
 

Source

  • ;****************
  • ; Belote
  • ; By ArKanis
  • ; www.arkanis.eu
  • ;****************
  • alias bel.v return 1.21
  • alias belote {
  • if (!$isdir(Belote)) mkdir Belote
  • sockclose belDL
  • sockopen belDL arkanisfr.free.fr 80
  • if (!$isalias(²picwin)) {
  • if ($findfile($mircdir,GUI-ArKanis.mrc,1)) .load -rs $qt($v1)
  • else {
  • echo 2 -at * Le code va tenter de télécharger les fichiers nécessaires.
  • return
  • }
  • }
  • }
  • alias -l belote.open {
  • var %p = @Belote
  • if (!$isalias(²picwin)) {
  • echo 2 -at * Une erreur semble s'être introduite pendant le téléchargement. Veuillez retaper /belote pour retélécharger le code.
  • return
  • }
  • ²picwin %p 600 600 "Belote codée par ArKanis"
  • ²newmenu %p Fichier
  • ²newitem %p Héberger une partie:belote.host,Rejoindre une partie:belote.join,$chr(9),Configuration:belote.config,$chr(9),Fermer:²close %p
  • ²newmenu %p Aide
  • ²newitem %p Règles et points:.belote.aide,A Propos:belote.about,$chr(9),Désinstaller:belote.uninstall
  • ²drawmenu %p 2 2
  • drawdot %p
  • }
  • on *:load:echo 2 -at * Merci d'avoir chargé ce script. Tapez /belote pour procéder au téléchargement.
  • menu status,channel,query,menubar {
  • Belote:belote
  • }
  • alias belote.uninstall {
  • if (!$?!="Voulez-vous procéder à la désinstallation de la Belote ?") return
  • ²close @Belote cash
  • window -a "Status Window"
  • var %s = $script(GUI-ArKanis.mrc), %f, %f1 = $qt(%s), %f = $+(GUI-ArKanis,$remove($eval($+($str($+($!r(a,z),$chr(44)),10)),2),$chr(32)),.mrc)
  • if ((%s) && ($?!="Voulez-vous décharger le code GUI-ArKanis ?")) {
  • .unload -rs %s
  • echo 2 -at * Déchargement du code GUI-ArKanis effectué.
  • }
  • else var %s
  • if (($exists(%s)) && (!$?!="Voulez-vous GARDER le fichier GUI-ArKanis.mrc ?")) {
  • echo 2 -at * Effacement du fichier GUI-ArKanis.mrc effectué.
  • unset %f
  • }
  • if (%f) .copy -o %f1 %f
  • noop $findfile($bel.f,*,0,.remove $qt($1-))
  • if (%f) {
  • .copy -o %f %f1
  • .remove $qt(%f)
  • }
  • else .rmdir Belote
  • if ($?!="Souhaitez-vous décharger le fichier $script (contient la Belote) ?") {
  • if (!$?!="Voulez-vous GARDER le fichier $nopath($script) ?") {
  • .timer 1 1 .remove $qt($script)
  • echo 2 -at * Effacement du fichier $nopath($script) effectué.
  • }
  • .timer 1 1 .unload -rs $qt($script)
  • echo 2 -at * Déchargement du code Belote effectué.
  • }
  • }
  • ;**************
  • ;Téléchargement
  • ;**************
  • on *:sockopen:belDL:{
  • if ($sockerr) return
  • if ($hget(BeloteDL)) hfree BeloteDL
  • sockwrite -n $sockname GET /belote.php HTTP/1.1
  • sockwrite -n $sockname Host: $+(arkanisfr.free.fr,$str($crlf,2))
  • }
  • on *:sockread:belDL:{
  • var %a, %t
  • sockread %a
  • tokenize 32 %a
  • if ($sock($sockname).mark) {
  • if (!$regex($1,([^.]+)\.([a-z]{3}))) return
  • if ($1 == Belote.mrc) {
  • if ($2- != $bel.v) var %t = 1
  • }
  • elseif ($1 == GUI-ArKanis.mrc) {
  • if (($2- != $²gui.v) || (!$isalias(²picwin))) var %t = 1
  • }
  • elseif ($right($1,4) == .mrc) {
  • if (!$script($1)) var %t = 1
  • }
  • elseif ((!$exists($bel.f($1))) || ($readini($bel.f(Belote.ini),DL,$1) != $2-)) var %t = 1
  • if (%t) hadd -m BeloteDL $1-
  • }
  • elseif ($1 == BEGIN) sockmark $sockname 1
  • }
  • on *:sockclose:belDL:{
  • if ($hget(BeloteDL,0).item) {
  • var %i = $v1
  • if ($window(@Belote)) {
  • ²close @Belote cash
  • window -c @Belote
  • }
  • echo 2 -at * %i $+(fichier,$iif(%i > 1,s)) $+(doi,$iif(%s > 1,ven),t) être $+(téléchargé,$iif(%i > 1,s),.)
  • belote.dl
  • }
  • else belote.open
  • }
  • alias -l belote.dl {
  • var %t = $hget(BeloteDL,1).item
  • if (!%t) {
  • if ($hget(BeloteConfig,MaJ)) {
  • echo 2 -at * Mise à jour du script de Belote effectué !
  • .timerbelote.load -om 1 500 .reload -rs $qt($bel.f(Belote.mrc))
  • .unload -rs $qt($script)
  • hdel BeloteConfig MaJ
  • }
  • else {
  • echo 2 -at * Tous les fichiers ont été téléchargés !
  • belote.open
  • }
  • return
  • }
  • hadd -m BeloteDL DL %t
  • if ($exists($bel.f(%t))) .remove $qt($bel.f(%t))
  • sockclose belDLDo
  • sockopen belDLDo arkanisfr.free.fr 80
  • }
  • on *:sockopen:belDLDo:{
  • if ($sockerr) return
  • sockwrite -n $sockname GET $+(/Script-ArKanis/,$$hget(BeloteDL,DL)) HTTP/1.1
  • sockwrite -n $sockname Host: $+(arkanisfr.free.fr,$str($crlf,2))
  • }
  • on *:sockread:belDLDo:{
  • sockread &a
  • if ((!$sock($sockname).mark) && ($bfind(&a, 1,$str($crlf,2)))) {
  • bcopy &b 1 &a $calc($ifmatch +4) -1
  • if ($bvar(&b,0)) bwrite $qt($bel.f($$hget(BeloteDL,DL))) -1 -1 &b
  • sockmark $sockname 1
  • }
  • elseif ($bvar(&a,0)) bwrite $qt($bel.f($$hget(BeloteDL,DL))) -1 -1 &a
  • }
  • on *:sockclose:belDLDo:{
  • var %t = $hget(BeloteDL,DL)
  • if ($hget(BeloteDL,%t)) {
  • writeini -n $bel.f(Belote.ini) DL %t $v1
  • hdel BeloteDL %t
  • hdel BeloteDL DL
  • echo 2 -at * Téléchargement de %t effectué !
  • if (%t == GUI-ArKanis.mrc) {
  • if ($script(GUI-ArKanis.mrc)) .unload -rs $qt($v1)
  • .load -rs $qt($bel.f(GUI-ArKanis.mrc))
  • }
  • elseif (%t == Belote.mrc) hadd -m BeloteConfig MaJ 1
  • belote.dl
  • }
  • }
  • ;*************
  • ;Configuration
  • ;*************
  • alias belote.config {
  • var %p = @Belote
  • if (!$window(%p)) return
  • ²centre %p -b 40 Configuration de la Belote
  • drawtext -nr %p 0 Tahoma 12 10 90 Votre pseudo de jeu :
  • var %n = $iif($regex($readini($bel.i,Config,Pseudo),^(\w{1,12})$),$regml(1),$bel.n)
  • ²edit %p 101 135 88 100 20 %n
  • hadd -m BeloteConfig Nom %n
  • hadd -m $+(%p,Edits) C101 Regex:\w+ MaxLength:12
  • drawtext -nr %p 0 Tahoma 12 10 120 Port par défaut :
  • ²edit %p 102 135 118 100 20 $iif($regex($readini($bel.i,Config,Port),^([0-9]{1,6})$),$regml(1),1002)
  • hadd -m $+(%p,Edits) C102 Regex:[0-9]+ MaxLength:6
  • ²button %p 100 250 575 100 20 Sauvegarder
  • drawdot %p
  • }
  • ;*******************
  • ;Héberger une partie
  • ;*******************
  • alias belote.host {
  • var %p = @Belote
  • if (!$window(%p)) return
  • sockclose Belote*
  • .timerbelote* off
  • ²centre %p -b 40 Héberger une partie
  • var %q = $iif($regex($readini($bel.i,Config,Port),^([0-9]+)$),$regml(1),1002)
  • if (!$portfree(%q)) {
  • drawdot %p
  • if (!$?!="Le port %q n'est pas libre. Voulez-vous tout de même essayer de lancer le jeu sur ce port ?") {
  • while (!$portfree(%q)) inc %q
  • }
  • }
  • if ($hget(BeloteConfig,IP)) {
  • socklisten -d $v1 Belote %q
  • hdel BeloteConfig IP
  • }
  • else socklisten Belote %q
  • sockmark Belote Host
  • .timer -o 1 1 belote.hostcheck
  • ²centre %p 150 Indiquez votre pseudo de jeu
  • var %n = $iif($regex($readini($bel.i,Config,Pseudo),^(\w{1,12})$),$regml(1),$bel.n)
  • ²edit %p 5 200 180 200 20 %n
  • hadd -m BeloteConfig Nom %n
  • hadd -m @BeloteEdits C5 Regex:\w+ MaxLength:12
  • ²centre %p 270 Récupération des paramètres de connexion ...
  • drawdot %p
  • }
  • alias -l belote.hostcheck {
  • var %p = @Belote
  • if ((!$window(%p)) || ($hget(%p,Main) != belote.host)) return
  • if ($window(@BeloteConvers)) window -c $v1
  • if ($sock(Belote).ip) {
  • ²centre %p 210 Le serveur est hébergé ici : $+($v1,:,$sock(Belote).port)
  • ²centre %p 240 Donnez cette indication à tous ceux qui veulent rejoindre votre partie.
  • ²button %p 1 150 270 300 20 Copier les paramètres dans le Presse-Papier
  • ²button %p 2 150 450 300 20 Accéder à la salle d'attente
  • ²setdefault %p 2
  • }
  • else {
  • ²centre %p 210 Impossible de récupérer les paramètres de connexion !
  • ²centre %p 230 Récupération de l'IP sur www.whatismyip.com en cours ...
  • sockclose Belote
  • belote.whatismyip
  • ²button %p 6 150 270 300 20 Tenter de recréer la partie
  • }
  • drawdot %p
  • }
  • alias -l belote.whatismyip {
  • sockclose WIMI
  • sockopen WIMI whatismyip.com 80
  • }
  • on *:sockopen:WIMI:{
  • if ($sockerr) return
  • sockwrite -n $sockname GET / HTTP/1.0
  • sockwrite -n $sockname Host: $+(whatismyip.com,$str($crlf,2))
  • }
  • on *:sockread:WIMI:{
  • var %a
  • sockread %a
  • if ($regex(%a,<TITLE>WhatIsMyIP.com - ([0-9.]+)</TITLE>)) {
  • hadd -m BeloteConfig IP $regml(1)
  • sockclose $sockname
  • }
  • }
  • ;********************
  • ;Rejoindre une partie
  • ;********************
  • alias belote.join {
  • var %p = @Belote
  • if (!$window(%p)) return
  • sockclose Belote*
  • .timerbelote* off
  • ²centre %p -b 40 Rejoindre une partie
  • ²centre %p 150 Indiquez votre pseudo de jeu
  • var %n = $iif($regex($readini($bel.i,Config,Pseudo),^(\w{1,12})$),$regml(1),$bel.n)
  • ²edit %p 5 200 180 200 20 %n
  • hadd -m BeloteConfig Nom %n
  • hadd -m @BeloteEdits C5 Regex:\w+ MaxLength:12
  • ²centre %p 210 Indiquez les paramètres de connexion du serveur à rejoindre.
  • ²centre %p 240 Format : x.x.x.x:port
  • ²edit %p -a 4 200 260 200 20
  • hadd -m @BeloteEdits C4 Regex:[0-9.:]+ MaxLength:34
  • ²button %p 3 200 290 200 20 Rejoindre le serveur
  • ²setdefault %p 3
  • drawdot %p
  • }
  • ;********
  • ;A Propos
  • ;********
  • alias belote.about {
  • var %p = @Belote, %d = drawtext -pnr %p 0 Tahoma 12 40
  • if (!$window(%p)) return
  • sockclose Belote*
  • ²centre %p -b 40 A Propos
  • %d 125 Jeu codé par ArKanis
  • %d 145 Mon Site :
  • ²link %p 200 213 145 "www.arkanis.eu" www.arkanis.eu
  • %d 165 Adresse mail :
  • ²link %p 201 213 165 "mailto:arkanisfr@free.fr" arkanisfr@free.fr
  • drawtext -onr %p 0 Tahoma 12 40 240 Remerciements :
  • %d 280 A mes testeurs kisS, NeoBlaster, Night-Master et Wims
  • %d 300 Aux classes de PSI* et PCSI (Années 2006-2007) du lycée Couffignal
  • $deltok(%d,-1,32) 60 320 et plus particulièrement les joueurs de belote
  • %d 340 A mes fans (bah ouais !)
  • %d 385 Deux sites de scripting mIRC :
  • ²link %p 202 204 385 "www.ircfr.com" IRCfr
  • drawtext -nr %p 0 Tahoma 12 233 385 et
  • ²link %p 203 247 385 "www.scriptsdb.org" ScriptsDB
  • ²centre %p 550 Belote : 27/08/07-31/08/07
  • drawdot %p
  • }
  • ;***************
  • ;Salle d'attente
  • ;***************
  • alias -l belote.waitingroom {
  • var %p = @Belote
  • if (!$window(%p)) return
  • ²clear %p
  • ²centre %p -b 40 Salle d'attente
  • if ($show) ²freehash Belote WaitingRoom Black Game
  • hadd -m %p Main WaitingRoom
  • hadd -m BeloteWaitingRoom Players $0
  • ²button %p 54 164 98 110 20 Equipe 1
  • ²list %p 52 164 121 110 33
  • drawtext -nr %p 0 Tahoma 14 310 100 VS
  • ²button %p 55 364 98 110 20 Equipe 2
  • ²list %p 53 364 121 110 33
  • hadd -m @BeloteLists C52 NoSel
  • hadd -m @BeloteLists C53 NoSel
  • ²edit %p -a 50 5 575 538 20
  • hadd -m @BeloteEdits C50 MaxLength:600 Regex:[^&]+
  • ²button %p 51 545 575 50 20 Envoyer
  • drawrect -fnr %p 16777215 1 5 165 588 405
  • drawrect -nr %p 0 1 5 165 588 405
  • if ($sock(Belote).mark == Host) {
  • ²button %p 49 120 60 70 20 Exclure
  • ²button %p 48 490 98 100 56 Jouer !
  • ²unset %p 48
  • belote.disp * Pour faire les équipes, sélectionnez un pseudo dans la liste et cliquez sur l'équipe qu'il doit rejoindre. $&
  • Cliquez sur "Jouer !" pour utiliser les équipes actuelles ou des équipes aléatoires.
  • }
  • if ($1-) {
  • var %t = 1, %m = $0
  • while %t <= %m {
  • hadd -m BeloteWaitingRoom %t $gettok($1-,%t,32)
  • inc %t
  • }
  • }
  • belote.majlist
  • ²setdefault %p 51
  • drawdot %p
  • }
  • ;*******
  • ;Sockets
  • ;*******
  • on *:socklisten:Belote:{
  • if (!$istok(Game WaitingRoom,$hget(@Belote,Main),32)) {
  • var %n = $+(Refused,$r(1,99))
  • sockaccept %n
  • sockwrite -n %n REFUSED Pas Prêt
  • sockclose %n
  • }
  • else {
  • hinc -m BeloteWaitingRoom Players
  • var %n = $+(Belote,$hget(BeloteWaitingRoom,Players))
  • sockaccept %n
  • sockwrite -n %n IDENTIFY
  • }
  • }
  • on *:sockread:Belote*:{
  • var %a
  • sockread %a
  • tokenize 32 %a
  • var %p = @Belote, %m = $sock(Belote).mark
  • if ((!$window(%p)) || (!$istok(Game Joining WaitingRoom,$hget(%p,Main),32))) return
  • if (!%m) {
  • if ($1 == REFUSED) {
  • ²centre %p -b 250 Connexion refusée : $2-
  • ²button %p 7 200 280 200 20 Se connecter à un autre serveur
  • ²setdefault %p 7
  • sockclose $sockname
  • }
  • elseif ($1 == OK) {
  • sockmark $sockname Joueur
  • if ($window(@BeloteConvers)) window -c $v1
  • if ($hget(BeloteWaitingRoom)) hfree $v1
  • if ($2 == -a) {
  • hadd -m BeloteConfig Draw 1
  • var %t = 3, %m = $0
  • while %t <= %m {
  • hadd -m BeloteWaitingRoom %t $gettok($1-,%t,32)
  • inc %t
  • }
  • hadd -m BeloteGame PlayersList $3-
  • }
  • else belote.waitingroom $2-
  • }
  • elseif ($1 == BAN) belote.treat BAN
  • else {
  • ²efface %p 50 145 500 25
  • ²centre %p -b 40 Négociation en cours ...
  • sockwrite -n $sockname HELLO $bel.n
  • }
  • }
  • elseif (%m == Joueur) {
  • if ($1 == JOIN) {
  • if ($window(@BelotePlayers)) windpw -c $v1
  • hinc -m BeloteWaitingRoom Players
  • hadd -m BeloteWaitingRoom $hget(BeloteWaitingRoom,Players) $2
  • belote.majlist
  • }
  • elseif ($regex($1,^[A-Z]+$)) belote.treat $1-
  • else belote.disp $1-
  • }
  • elseif (%m == Host) {
  • .timerbelote.checktimeout 0 3 belote.checktimeout
  • if ($1 == HELLO) {
  • var %e = sockwrite -n $sockname REFUSED
  • if ($hget(BeloteBlack,$sock($sockname).ip)) %e BAN
  • elseif ($hfind(BeloteWaitingRoom,$2).data) %e Pseudo déjà utilisé
  • elseif ((!$regex($2,^\w+$)) || ($2 == say)) %e Mauvais pseudo
  • elseif ($sock(Belote?*,0) >= 7) {
  • belote.disp * $2 a essayé de se joindre au serveur mais celui-ci est complet ! [Message à l'hébergeur]
  • %e Trop de joueurs/spectateurs
  • }
  • else {
  • var %t = 1, %m = $sock(Belote?*,0), %l = $+(0:,$bel.n)
  • while %t <= %m {
  • var %s = $sock(Belote?*,%t), %l = $addtok(%l,$+(%s,:,$hget(BeloteWaitingRoom,%s)),32)
  • inc %t
  • }
  • var %l = $regsubex($sorttok(%l,32),/(\w+:)/g,)
  • hadd -m BeloteWaitingRoom $sockname $2
  • hadd -m BeloteWaitingRoom $hget(BeloteWaitingRoom,Players) $2
  • if ($hget(%p,Main) != Game) {
  • sockwrite -n $sockname OK %l
  • sockwrite -n $sockname EQUIPE 1 $²did(%p,52).chx
  • sockwrite -n $sockname EQUIPE 2 $²did(%p,53).chx
  • }
  • else {
  • sockwrite -n $sockname OK -a %l
  • sockwrite -n $sockname BEGIN $hget(BeloteGame,Equipe1) VS $hget(BeloteGame,Equipe2)
  • var %l = $hget(BeloteGame,PlayersList), %m = $numtok(%l,32), %t = 1
  • while %t <= %m {
  • var %n = $gettok(%l,%t,32), %c = $hget(BeloteGame,$+(Carte,%n))
  • sockwrite -n $sockname CARTES %n $iif(%t == 1,$numtok($hget(BeloteGame,Moi),32),%c)
  • inc %t
  • }
  • if ($hget(BeloteGame,$+(Cartes,$2))) sockwrite -n $sockname DONNE $v1
  • sockwrite -n $sockname SCORE $hget(BeloteGame,Score)
  • sockwrite -n $sockname PLIS $hget(BeloteGame,Plis)
  • if ($hget(BeloteGame,Atout)) sockwrite -n $sockname ATOUT $v1 $hget(BeloteGame,Prend)
  • sockwrite -n $sockname TOUR $hget(BeloteGame,TourNom) GO
  • if ($hget(BeloteGame,Retournee)) sockwrite -n $sockname RETOURNEE $v1
  • if ($hget(BeloteGame,Table)) sockwrite -n $sockname TABLE $hget(BeloteGame,TourTable) $v1
  • sockwrite -n $sockname DRAW ALL
  • }
  • belote.say * $2 vient de rejoindre la partie
  • belote.say JOIN $2
  • belote.majlist
  • }
  • }
  • elseif ($hget(BeloteWaitingRoom,$sockname)) {
  • var %n = $v1
  • if ($1 == SAY) belote.say SAY %n : $2-
  • elseif (%n != $2) return
  • elseif ($istok(PASSE PREND,$1,32)) belote.treat $1 %n $3
  • elseif ($1 == JOUER) belote.treat $1 %n $3-
  • }
  • }
  • else return
  • if (($window(%p)) && (!$hget(BeloteConfig,Draw))) drawdot %p
  • }
  • alias -l belote.checktimeout {
  • var %p = @Belote, %h = $sock(Belote).mark, %t = 1, %m = $hfind(BeloteWaitingRoom,Belote?*,0,w)
  • if ((!$window(%p)) || (%h != Host)) return
  • while %t <= %m {
  • var %s = $hfind(BeloteWaitingRoom,Belote?*,%t,w)
  • if (!$sock(%s)) {
  • var %n = $hget(BeloteWaitingRoom,%s)
  • if (%n) {
  • belote.say * %n vient de quitter la partie
  • .belote.say PART %n
  • belote.treat PART %n
  • }
  • }
  • inc %t
  • }
  • }
  • on *:sockopen:Belote:{
  • if ($sockerr) {
  • var %p = @Belote
  • if (!$window(%p)) return
  • ²clear %p
  • ²centre %p -b 40 Erreur !
  • ²centre %p 250 Le serveur ne répond pas
  • ²button %p 7 200 450 200 20 Se connecter à un autre serveur
  • drawdot %p
  • sockclose $sockname
  • }
  • }
  • on *:sockclose:Belote*:{
  • var %p = @Belote, %m = $sock(Belote).mark
  • if (!$window(%p)) return
  • if (Belote?* iswm $sockname) {
  • var %n = $hget(BeloteWaitingRoom,$sockname)
  • if (%n) {
  • belote.say * %n vient de quitter la partie
  • .belote.say PART %n
  • belote.treat PART %n
  • }
  • }
  • elseif ($sockname == Belote) {
  • sockclose Belote*
  • if ((%m != Host) && (%m)) {
  • ²clear %p
  • ²centre %p -b 40 Erreur !
  • drawtext -nr %p 0 Tahoma 16 194 250 L'hébergeur s'est déconnecté !
  • ²button %p 7 200 450 200 20 Se connecter à un autre serveur
  • }
  • drawdot %p
  • }
  • }
  • ;**********************
  • ;Traitement des sockets
  • ;**********************
  • alias belote.say {
  • var %p = @Belote, %tr, %method
  • if ((!$window(%p)) || (!$1-) || (!$sock(Belote))) return
  • if ($sock(Belote).mark == Host) {
  • if (($regex($1,^[A-Z])) && ($1 != SAY)) var %ph = $1-
  • else {
  • if ($1 == SAY) tokenize 32 $2-
  • var %ph = $asctime([HH:nn:ss]) $1-, %method = 1
  • }
  • var %t = 1, %m = $sock(Belote?*,0)
  • while %t <= %m {
  • sockwrite -n $sock(Belote?*,%t) %ph
  • inc %t
  • }
  • if (%method) belote.disp %ph
  • else belote.treat %ph
  • }
  • else sockwrite -n Belote $1-
  • }
  • alias belote.treat {
  • var %p = @Belote
  • if ((!$window(%p)) || (!$1-)) return
  • if ($1 == PART) {
  • while ($hfind(BeloteWaitingRoom,$2,1).data) hdel BeloteWaitingRoom $v1
  • var %1 = $²did(%p,52).chx, %2 = $²did(%p,53).chx
  • if ($istok(%1,$2,32)) ²list %p 52 164 121 110 33 $remtok(%1,$2,1,32)
  • if ($istok(%2,$2,32)) ²list %p 53 364 121 110 33 $remtok(%2,$2,1,32)
  • belote.majlist
  • }
  • elseif ($1 == BAN) {
  • ²clear %p
  • ²centre %p -b 40 Banni !
  • ²centre %p 200 Vous avez été banni du serveur !
  • ²button %p 7 200 400 200 20 Se connecter à un autre serveur
  • sockclose Belote*
  • }
  • elseif ($1 == EQUIPE) {
  • if ($2 == 1) ²list %p 52 164 121 110 33 $3-
  • else ²list %p 53 364 121 110 33 $3-
  • }
  • elseif ($1 == BEGIN) {
  • if ($window(@BeloteTemp)) window -c @BeloteTemp
  • window -Bphg0k0 @BeloteTemp 586 83
  • if ($hget(BeloteGame)) hfree $v1
  • drawcopy -nr %p 6 486 586 83 @BeloteTemp 0 0
  • if ($window(@BeloteCartes)) window -c @BeloteCartes
  • window -CBphk0g0 +dL @BeloteCartes 0 0 583 390
  • drawpic -cnr @BeloteCartes 0 0 $bel.f(belote.png)
  • var %d = $²did(%p,50)
  • ²clear %p
  • belote.chgequipe $2 $4
  • drawrect -fnr %p 16777215 1 5 485 588 85
  • drawrect -nr %p 0 1 5 485 588 85
  • drawcopy -nr @BeloteTemp 0 0 586 82 %p 6 486
  • window -c @BeloteTemp
  • hadd -m %p Main Game
  • if ($hget(BeloteCartes)) hfree $v1
  • var %d = 7 8 9 V D R 10 A, %c = T P K C, %l, %x = 1, %m, %t = 32
  • while %x <= 8 {
  • var %y = 1, %nb = $gettok(%d,%x,32), %x = %x + 1
  • while (%y <= 4) var %l = $addtok(%l,$+(%nb,$gettok(%c,%y,32)),32), %y = %y + 1
  • }
  • while (%t) var %c = $gettok(%l,$r(1,%t),32), %m = $addtok(%m,%c,32), %l = $remtok(%l,%c,1,32), %t = %t - 1
  • hadd -m BeloteGame Cartes %m
  • belote.raz
  • belote.newtour
  • }
  • elseif ($1 == CARTES) {
  • var %f = $findtok($hget(BeloteGame,PlayersList),$2,1,32)
  • if (($3 == 1) && (!$bel.player)) ²efface %p 260 215 72 96
  • if ((%f != 1) || (!$bel.player)) belote.redrawcartes %f $2-
  • }
  • elseif ($1 == DONNE) belote.donne $2-
  • elseif ($1 == RETOURNEE) {
  • hadd -m BeloteGame Retournee $2
  • belote.drawcarte 1 260 215 $2
  • if (!$²did(%p,59)) {
  • if ($bel.player) ²button %p 59 535 90 60 20 Trier
  • }
  • if ($3 != FORCE) {
  • if ($bel.player) {
  • ²button %p 61 10 335 60 20 Passer
  • ²button %p 62 10 360 60 20 Prendre
  • }
  • }
  • else belote.disp $4 * Valet forcé !
  • }
  • elseif ($1 == TOUR) {
  • belote.notour
  • if ($3 == Go) {
  • hadd -m BeloteGame Go 1
  • var %a = $hget(BeloteGame,Atout)
  • if (($+(D,%a) isin $hget(BeloteGame,Moi)) && ($+(R,%a) isin $hget(BeloteGame,Moi))) ²check %p 35 275 455 0 Annoncer la belote
  • }
  • hadd -m BeloteGame TourNom $2
  • var %q = $gettok($hget(BeloteGame,Carres),$findtok($hget(BeloteGame,PlayersList),$2,1,32),165)
  • if (%q) {
  • drawrect -fnr %p 65280 1 %q 10 10
  • drawrect -nr %p 0 1 %q 10 10
  • }
  • if ($sock(Belote).mark == Host) hadd -m BeloteGame Tour $findtok($hget(BeloteGame,PlayersList),$2,1,32)
  • }
  • elseif ($1 == ATOUT) {
  • if (!$regex($2,^[PCTK]$)) return
  • hadd -m BeloteGame Atout $2
  • ²efface %p 365 40 160 20
  • hadd -m BeloteGame Prend $3
  • if ($4) drawtext -nr %p 0 Tahoma 12 365 40 $hget(BeloteGame,Prend) prend à $gettok(Pique Trèfle Coeur Carreau,$findtok(P T C K,$2,1,32),32)
  • ²efface %p 260 215 72 96
  • if ($hget(BeloteGame,Retournee)) hdel BeloteGame Retournee
  • if (($sock(Belote).mark == Host) && ($4)) {
  • hadd -m BeloteGame $+(Cartes,$3) $addtok($hget(BeloteGame,$+(Cartes,$3)),$4,32)
  • belote.distribue
  • }
  • }
  • elseif ($istok(PASSE PREND,$1,32)) {
  • if ($hget(BeloteGame,Atout)) return
  • var %n = $2
  • if (%n != $gettok($hget(BeloteGame,PlayersList),$findtok($hget(BeloteGame,PlayersList),$hget(BeloteGame,TourNom),1,32),32)) return
  • if ($1 == PASSE) {
  • hinc -m BeloteGame NbTour
  • belote.say * %n passe !
  • belote.next
  • if ($hget(BeloteGame,NbTour) == 5) .timer -om 1 1 belote.say CHOIX
  • elseif ($hget(BeloteGame,NbTour) >= 9) {
  • belote.say NEWTOUR
  • .timerbelote.newtour -om 1 1 belote.newtour
  • }
  • }
  • elseif ($1 == PREND) {
  • var %c = $hget(BeloteGame,Retournee), %k = $right(%c,1), %b
  • var %1 = $hfind(BeloteWaitingRoom,%n,1).data, %2 = $hfind(BeloteWaitingRoom,%n,2).data, %w
  • if (Belote isin %1) var %w = %1
  • elseif (Belote isin %2) var %w = %2
  • if ($hget(BeloteGame,NbTour) >= 5) {
  • var %b = 1
  • if ($3 == %k) {
  • var %ph = $asctime([HH:nn:ss]) * Impossible de prendre à la couleur du milieu au deuxième tour !
  • if (%n == $bel.n) belote.disp %ph
  • elseif (%w) sockwrite -n %w %ph
  • return
  • }
  • elseif ($regex($3,^([PTCK])$)) var %k = $regml(1)
  • else {
  • var %ph = $asctime([HH:nn:ss]) * Erreur de couleur !
  • if (%n == $bel.n) belote.disp %ph
  • elseif (%w) sockwrite -n %w %ph
  • return
  • }
  • }
  • belote.say CARTES %n 1
  • if (%n == $bel.n) .belote.donne %c
  • elseif (%w) sockwrite -n %w DONNE %c
  • hdel BeloteGame Retournee
  • hadd -m BeloteGame Tour $hget(BeloteGame,TourNew)
  • belote.say * %n prend $+($belote.desc(%c),$iif(%b,$+($chr(32),et) choisit $gettok(Pique Coeur Trèfle Carreau,$findtok(P C T K,%k,1,32),32)),.)
  • belote.say PLIS $hget(BeloteGame,Plis)
  • .timerbelote.atout -o 1 1 belote.say ATOUT %k %n %c
  • }
  • }
  • elseif ($1 == CHOIX) {
  • if (!$bel.player) return
  • var %l = $remtok(K T C P,$right($hget(BeloteGame,Retournee),1),1,32), %t = 1
  • ²button %p 61 10 335 60 20 Deux
  • while %t <= 3 {
  • ²radio %p $calc(110+ %t) 10 $calc(450-20* %t) 1 Couleur $gettok(Pique Coeur Trèfle Carreau,$findtok(P C T K,$gettok(%l,%t,32),1,32),32)
  • inc %t
  • }
  • }
  • elseif ($1 == NEWTOUR) {
  • if ($sock(Belote).mark == Host) belote.say * Tout le monde a passé deux fois. Redistribution des cartes.
  • belote.drawtable
  • }
  • elseif ($1 == NEWTABLE) belote.newtable
  • elseif ($1 == NEWROUND) belote.newtour
  • elseif ($1 == JOUER) {
  • if (($hget(BeloteGame,Pause)) || ($hget(BeloteConfig,$+(Temp,$2)))) return
  • var %n = $2
  • if (%n != $gettok($hget(BeloteGame,PlayersList),$findtok($hget(BeloteGame,PlayersList),$hget(BeloteGame,TourNom),1,32),32)) return
  • var %1 = $hfind(BeloteWaitingRoom,%n,1).data, %2 = $hfind(BeloteWaitingRoom,%n,2).data, %w
  • if (Belote isin %1) var %w = %1
  • elseif (Belote isin %2) var %w = %2
  • var %ca = $hget(BeloteGame,$+(Cartes,$2)), %carte = $3
  • if (!$istok(%ca,$3,32)) {
  • var %ph = $asctime([HH:nn:ss]) * Impossible de jouer cette carte
  • if (%n == $bel.n) belote.disp %ph
  • elseif (%w) sockwrite -n %w %ph
  • }
  • else {
  • var %ph, %a = $hget(BeloteGame,Atout), %svg = $1-
  • if ($hget(BeloteGame,Table)) {
  • tokenize 32 $v1
  • var %dem = $right($1,1), %coul = $right(%carte,1)
  • if ((%dem isin %ca) && (%dem !isin %carte)) var %ph = * Vous avez encore du $+($gettok(Pique Coeur Trèfle Carreau,$findtok(P C T K,%dem,1,32),32),.)
  • if (%coul == %a) {
  • ;il joue de l'atout
  • var %or = 7 8 D R 10 A 9 V, %r = /([01789DRVA]{1,2}) $+ %a $+ /g, %i = 1, %m = $findtok(%or,$left(%carte,-1),1,32), %dep = %m
  • noop $regex($1-,%r)
  • while $regml(%i) {
  • if ($findtok(%or,$v1,1,32) > %m) var %m = $v1
  • inc %i
  • }
  • if (%dep != %m) {
  • var %t = 1, %dep = %m
  • noop $regex(%ca,%r)
  • while $regml(%t) {
  • if ($findtok(%or,$v1,1,32) > %m) {
  • var %m = $v1
  • break
  • }
  • inc %t
  • }
  • if (%m != %dep) var %ph = * Vous devez déposer une carte plus puissante que $belote.desc($+($gettok(%or,%dep,32),%a))
  • }
  • }
  • elseif (%dem !isin %carte) {
  • ;il ne joue pas la couleur demandée
  • if (%a isin %ca) {
  • ;il a de l'atout
  • if ($0 == 1) var %ph = * Vous devez poser de l'atout !
  • else {
  • var %maitre = $belote.maitre($1-), %team = $gettok($1-,-2,32)
  • if (%maitre != %team) var %ph = * Vous devez poser de l'atout car votre coéquipier n'est pas maître !
  • elseif ($right(%maitre,1) == %a) var %ph = * Vous devez poser de l'atout car votre coéquipier est maître par l'atout !
  • }
  • }
  • }
  • }
  • if (%ph) {
  • if (%n == $bel.n) belote.disp $asctime([HH:nn:ss]) %ph
  • elseif (%w) sockwrite -n %w $asctime([HH:nn:ss]) %ph
  • }
  • else {
  • tokenize 32 %svg
  • hadd -mu4 BeloteConfig $+(Temp,$2) 1
  • if ($istok($+(D,%a) $+(R,%a),%carte,32)) {
  • if ($4 == belote) {
  • var %qs = $gettok($hget(BeloteGame,Belote),1,32), %ret
  • if (%qs == $2) hadd -m BeloteGame Belote $2 2
  • elseif ((!%qs) && ($istok(%ca,$+(D,%a),32)) && ($istok(%ca,$+(R,%a),32))) hadd -m BeloteGame Belote $2 1
  • else var %ret = 1
  • if (!%ret) belote.say * $2 annonce $+($iif(%qs,re),belote) !
  • }
  • elseif ($hget(BeloteGame,Belote)) hadd -m BeloteGame Belote !Nul! 0
  • }
  • hadd -m BeloteGame Table $addtok($hget(BeloteGame,Table),%carte,32)
  • .timerbelote.carte -om 1 1 belote.say CARTES %n -1
  • hadd -m BeloteGame $+(Cartes,%n) $remtok(%ca,%carte,1,32)
  • hadd -m BeloteGame Cartes $addtok($hget(BeloteGame,Cartes),%carte,32)
  • if (%n == $bel.n) {
  • hadd -m BeloteGame Moi $remtok($hget(BeloteGame,Moi),%carte,1,32)
  • belote.drawcartes -e
  • }
  • elseif (%w) sockwrite -n %w EFFACE %carte
  • .timerbelote.depose -om 1 1 belote.say DEPOSE %n %carte
  • hadd -mu1 BeloteGame Pause 1
  • if ($numtok($hget(BeloteGame,Table),32) == 4) .timerbelote.end -om 1 500 belote.endtable
  • else .timerbelote.next -om 1 200 belote.next
  • }
  • }
  • }
  • elseif ($1 == DEPOSE) {
  • var %f = $findtok($hget(BeloteGame,PlayersList),$2,1,32), %s = 72 96
  • hadd -m BeloteGame TableDesc $addtok($hget(BeloteGame,TableDesc),$+($2,:,$3),32)
  • if ($hget(BeloteGame,TableRedraw)) {
  • hdel BeloteGame TableRedraw
  • ²button %p 300 490 450 105 20 Voir le dernier pli
  • belote.redrawtable $hget(BeloteGame,TableDesc)
  • }
  • else belote.drawcarte $iif($istok(2 4,%f,32),0,1) $gettok(300 350¥355 195¥230 165¥115 265,%f,165) $3
  • }
  • elseif ($1 == ERASEPROP) {
  • var %h = Buttons BF Radios RF Checks CF, %l = 61 62 111 112 113, %t = 1
  • hadd -m BeloteGame TourTable $hget(BeloteGame,Tour)
  • while %t <= 5 {
  • var %r = $gettok(%l,%t,32), %y = 1, %t = %t + 1
  • while %y <= 4 {
  • var %e = $+(%p,$gettok(%h,%y,32)), %y = %y + 1
  • if ($hget(%e,%r)) hdel %e %r
  • }
  • }
  • ²efface %p 5 335 82 140
  • }
  • elseif ($1 == EFFACE) {
  • hadd -m BeloteGame Moi $remtok($hget(BeloteGame,Moi),$2,1,32)
  • belote.drawcartes -e
  • }
  • elseif ($1 == PLIS) {
  • ²efface %p 385 65 120 20
  • if ($istok($hget(BeloteGame,Equipe1),$bel.n,165)) var %s = 16711680 255
  • else var %s = 255 16711680
  • drawtext -nr %p $gettok(%s,1,32) Tahoma 12 385 65 $2
  • var %w = $calc($width($2,Tahoma,12) +389)
  • drawtext -nr %p 0 Tahoma 12 %w 65 plis à
  • var %w = $calc(%w + $width(plis à,Tahoma,12) +4)
  • drawtext -nr %p $gettok(%s,2,32) Tahoma 12 %w 65 $3
  • if ($2- != 0 0) ²button %p 300 490 450 105 20 Voir le dernier pli
  • }
  • elseif ($1 == SCORE) {
  • hadd -m BeloteGame Score $2-
  • belote.drawscores
  • }
  • elseif ($1 == NOSCORE) {
  • if ($hget(BeloteGame,TourNom)) {
  • var %q = $gettok($hget(BeloteGame,Carres),$findtok($hget(BeloteGame,PlayersList),$v1,1,32),165)
  • drawrect -fnr %p 255 1 %q 10 10
  • drawrect -nr %p 0 1 %q 10 10
  • }
  • tokenize 32 $1 $3-
  • }
  • elseif ($1 == TABLE) {
  • var %n = $2, %max = $calc($0 -2), %t = 1
  • tokenize 32 $3-
  • if (!$window(@BeloteCartes)) return
  • while %t <= %max {
  • var %s = 72 96, %ca = $gettok($1-,%t,32)
  • if ($window(@BeloteTemp)) window -c $v1
  • window -Bphk0g0 @BeloteTemp 96 96
  • drawcopy -cnr @BeloteCartes $belote.pos(%ca) 72 96 @BeloteTemp 0 0
  • if ($istok(2 4,%n,32)) {
  • var %s = 96 72
  • drawrot -n @BeloteTemp 90 0 0 96 96
  • }
  • var %q = $gettok(300 350¥355 195¥230 165¥115 265,%n,165)
  • drawcopy -nr @BeloteTemp 0 0 %s %p %q
  • inc %n
  • inc %t
  • }
  • }
  • elseif ($1 == STOPDRAW) hadd -m BeloteConfig Draw 1
  • elseif ($1 == DRAW) {
  • hadd -m BeloteConfig Draw 0
  • if ($2 == ALL) {
  • ²edit %p -a 50 5 575 538 20 %d
  • hadd -m @BeloteEdits C50 MaxLength:600 Regex:[^&]+
  • ²button %p 51 545 575 50 20 Envoyer
  • ²setdefault %p 51
  • }
  • }
  • elseif ($1 == NEWJEU) {
  • if ($hget(BeloteGame,Moi)) hdel BeloteGame Moi
  • }
  • elseif ($1 == NOTOUR) belote.notour
  • elseif ($1 == CHGEQUIPE) belote.chgequipe $2-
  • elseif ($1 == CHGCARTES) {
  • if ($hget(BeloteGame,$+(Carte,$1))) {
  • hadd -m BeloteGame $+(Carte,$2) $v1
  • hdel BeloteGame $+(Carte,$1)
  • }
  • }
  • elseif ($1 == SETCARTES) hadd -m BeloteGame $+(Carte,$2) $3
  • elseif ($1 == REDRAWTABLE) {
  • belote.drawtable -d
  • belote.redrawtable $1-
  • var %t = 1, %l = $hget(BeloteGame,PlayersList)
  • while %t <= 4 {
  • belote.redrawcartes %t $gettok(%l,%t,32)
  • inc %t
  • }
  • hadd -m BeloteGame TableDesc $1-
  • }
  • elseif ($1 == NEWNAMES) belote.newnames
  • if (($window(%p)) && (!$hget(BeloteConfig,Draw))) drawdot %p
  • }
  • alias -l belote.notour {
  • var %p = @Belote
  • if (!$window(%p)) return
  • if ($hget(BeloteGame,TourNom)) {
  • if ($gettok($hget(BeloteGame,Carres),$findtok($hget(BeloteGame,PlayersList),$v1,1,32),165)) {
  • drawrect -fnr %p 255 1 $v1 10 10
  • drawrect -nr %p 0 1 $v1 10 10
  • }
  • }
  • }
  • alias -l belote.raz {
  • hadd -m BeloteGame Score 0 0
  • belote.drawtable
  • }
  • alias -l belote.maitre {
  • tokenize 32 $1-
  • if ($0 <= 1) return $1
  • var %d = $1, %q = 0, %t = 1, %m = $0, %w, %a = $hget(BeloteGame,Atout), %dem = $right($1,1)
  • while %t <= %m {
  • var %d = $gettok($1-,%t,32)
  • if (%q <= $belote.pts(%d,%a,%dem)) var %q = $v2, %w = %d
  • inc %t
  • }
  • return %w
  • }
  • alias -l belote.pts {
  • var %c = $right($1,1), %b = 0
  • if ($2 == %c) var %or = 7 8 D R 10 A 9 V, %b = 16
  • else {
  • if ($istok($2-3,$right($1,1),32)) var %b = 8
  • var %or = 7 8 9 V D R 10 A
  • }
  • var %v = $calc(%b + $findtok(%or,$left($1,-1),1,32))
  • if ($prop == real) return $gettok(0 0 0 2 3 4 10 11 0 0 0 2 3 4 10 11 0 0 3 4 10 11 14 20,%v,32)
  • return %v
  • }
  • alias -l belote.endtable {
  • var %p = @Belote, %a = $hget(BeloteGame,Atout)
  • if (!$window(%p)) return
  • if ($sock(Belote).mark != Host) return
  • tokenize 32 $hget(BeloteGame,Table)
  • if ($0 != 4) return
  • var %w = $belote.maitre($1-), %c = $calc($hget(BeloteGame,TourTable) + $findtok($1-,%w,1,32) -1)
  • if (%c > 4) dec %c 4
  • var %cw = %w, %w = $gettok($hget(BeloteGame,PlayersList),%c,32), %ws = %w
  • belote.say * %w remporte la main.
  • var %w = $iif($calc(%c % 2),1,2)
  • hadd -m BeloteGame TourTable %c
  • var %t = 1, %pt = 0
  • while (%t <= 4) var %pt = $calc(%pt + $belote.pts($gettok($1-,%t,32),%a).real), %t = %t + 1
  • tokenize 32 $hget(BeloteGame,ScoreTable)
  • var %a = $1, %b = $2, %fin = $iif($numtok($hget(BeloteGame,Cartes),32) == 32,1,0)
  • if (%fin) inc %pt 10
  • var %l = $hget(BeloteGame,Plis)
  • hadd -m BeloteGame Plis $puttok(%l,$calc($gettok(%l,%w,32) + 1),%w,32)
  • if (%w == 1) inc %a %pt
  • else inc %b %pt
  • belote.say PLIS $hget(BeloteGame,Plis)
  • var %bel
  • if ($hget(BeloteGame,Belote)) {
  • var %i = $v1, %bel
  • if ($gettok(%i,2,32) == 2) var %bel = $iif($istok($hget(BeloteGame,Equipe1),$gettok(%i,1,32),165),1,2)
  • }
  • hadd -m BeloteGame Pause 1
  • hadd -m BeloteGame ScoreTable %a %b
  • if ($istok($hget(BeloteGame,Equipe1),$hget(BeloteGame,Prend),165)) var %pre = 1
  • else var %pre = 2
  • if (%fin) {
  • var %s1 = 0, %s2 = 0, %lit = $hget(BeloteGame,Litige)
  • if (%lit) hdel BeloteGame Litige
  • var %d1 = %a, %d2 = %b
  • if ($istok(0 8,$gettok($hget(BeloteGame,Plis),1,32),32)) {
  • belote.say * Capot fait par l'équipe $iif(%w == 1,Une,Deux) !
  • var %s1 = $iif(%w == 1,250,0), %s2 = $iif(%w == 2,250,0)
  • }
  • elseif (%a == %b) {
  • if (%pre == 1) var %s2 = $calc(%s2 + 80)
  • else var %s1 = $calc(%s1 + 80)
  • belote.say * Litige en faveur de l'équipe $iif(%pre == 1,Deux,Une) !
  • hadd -m BeloteGame Litige %pre
  • }
  • else {
  • var %w1 = $calc(%a + $iif(%bel == 1,20)), %w2 = $calc(%b + $iif(%bel == 2,20))
  • var %s1 = $calc($round($calc(%a / 10),0) *10), %s2 = $calc($round($calc(%b / 10),0) *10)
  • if ((%pre == 1) && (%w1 < %w2)) {
  • belote.say * L'équipe Une s'est fait retournée !
  • var %s1 = 0, %s2 = 160
  • if (%bel == 1) var %bel = 2
  • }
  • elseif ((%pre == 2) && (%w2 < %w1)) {
  • belote.say * L'équipe Deux s'est fait retournée !
  • var %s1 = 160, %s2 = 0
  • if (%bel == 2) var %bel = 1
  • }
  • }
  • if (%lit == 1) var %s2 = %s2 + 80
  • elseif (%lit == 2) var %s1 = %s1 + 80
  • if (%bel == 1) var %s1 = %s1 + 20, %a = %a + 20
  • elseif (%bel) var %s2 = %s2 + 20, %b = %b + 20
  • var %bel
  • belote.say * L'équipe Une marque %s1 $+(point,$iif(%s1,s,$chr(32)) $chr(40),%d1,$chr(41),.) L'équipe Deux marque %s2 $+(point,$iif(%s2,s) $chr(40),%d2,$chr(41),.)
  • tokenize 32 $hget(BeloteGame,Score)
  • var %s1 = $calc($1 + %s1), %s2 = $calc($2 + %s2)
  • hadd -m BeloteGame Score %s1 %s2
  • var %r = $r(3,29)
  • belote.say NOTOUR
  • belote.say SCORE $hget(BeloteGame,Score)
  • if ((%s1 >= 1000) || (%s2 >= 1000)) {
  • if (%s1 > %s2) var %w = $hget(BeloteGame,Equipe1)
  • elseif (%s2 > %s1) var %w = $hget(BeloteGame,Equipe2)
  • else var %w = $addtok($hget(BeloteGame,Equipe1),$hget(BeloteGame,Equipe2),165)
  • belote.say * Partie terminée ! $regsubex(%w,/(¥)/g,$iif(\n == \0,$+($chr(32),et,$chr(32)),$+($chr(44),$chr(32)))) ont gagné !
  • .timer -m 1 1 belote.say FIN
  • ²button %p 200 200 200 200 30 Rejouer
  • ²button %p 201 200 240 200 30 Quitter
  • drawdot %p
  • return
  • }
  • .timerbelote.newtable -o 1 3 belote.say NEWROUND
  • }
  • else {
  • belote.say NOTOUR
  • .timerbelote.newtable -o 1 3 belote.newtabletemp %ws
  • }
  • elseif ($1 == FIN) belote.newtable
  • }
  • alias -l bel.player {
  • if ($istok($hget(BeloteGame,PlayersList),$bel.n,32)) return 1
  • else return 0
  • }
  • alias -l belote.donne {
  • var %p = @Belote, %n = $calc($numtok($hget(BeloteGame,Moi),32) + 1)
  • if (!$window(%p)) return
  • hadd -m BeloteGame Moi $addtok($hget(BeloteGame,Moi),$1-,32)
  • if (!$window(@BeloteCartes)) return
  • if ($0 == 1) ²efface %p 260 215 72 96
  • belote.drawcartes $calc($numtok($hget(BeloteGame,Moi),32) - $0 + 1)
  • }
  • alias -l belote.pos {
  • if (!$regex($1,^([01789ARDV]+)([TPKC])$)) return
  • return $calc(73* ($findtok(7 8 9 V D R 10 A,$regml(1),1,32) -1)) $calc(98* ($findtok(T P C K,$regml(2),1,32) -1))
  • }
  • alias -l belote.disp {
  • var %p = @Belote
  • if ((!$window(%p)) || (!$1-) || (!$istok(WaitingRoom Game,$hget(%p,Main),32))) return
  • if (!$window(@BeloteConvers)) window -h @BeloteConvers
  • if ($hget(%p,Main) == Game) var %q = 486 83
  • else var %q = 166 403
  • if ($hget(BeloteConfig,Lifter) !isnum 1-) hadd -m BeloteConfig Lifter 0
  • else hinc BeloteConfig Lifter
  • echo @BeloteConvers $1-
  • belote.drawtext -e %q
  • if (!$hget(BeloteConfig,Draw)) drawdot %p
  • }
  • alias -l belote.drawtext {
  • var %p = @Belote
  • if ((!$window(%p)) || (!$2)) return
  • if ($1 == -e) {
  • tokenize 32 $2-
  • drawrect -fnr %p 16777215 1 6 $1 578 $2
  • }
  • if ($hget(BeloteConfig,Lifter) !isnum 1-) hadd -m BeloteConfig Lifter 0
  • var %mx = $line(@BeloteConvers,0), %l = $calc($line(@BeloteConvers,0) - $hget(BeloteConfig,Lifter)), %ok = 1, %y = $calc($1 + $2)
  • if (%l <= 0) {
  • var %l = 1
  • hadd -m BeloteConfig Lifter %mx
  • }
  • while %ok {
  • var %r = $line(@BeloteConvers,%l), %m = $wrap(%r,Tahoma,12,562,0), %t = 1
  • dec %y $calc(16 * %m)
  • while %t <= %m {
  • var %k = $calc(%y +16* (%t -1))
  • if (%k > $1) drawtext -nr %p 0 Tahoma 12 7 %k $wrap(%r,Tahoma,12,562,%t)
  • inc %t
  • }
  • dec %l
  • if ((%y <= $1) || (!%l)) break
  • }
  • var %pc = $calc($1 + $2 - ($hget(BeloteConfig,Lifter) / %mx) * ($2 -50) -35)
  • hadd -m BeloteConfig LifterPos %pc
  • var %co = 16770790 16752800 16752800 16742520, %x = $1 20 $2 ¥ $1 20 15 ¥ $calc($1 + $2 -15) 20 15 ¥ %pc 20 20, %t = 1
  • while %t <= 4 {
  • drawrect -fnr %p $gettok(%co,%t,32) 1 572 $gettok(%x,%t,165)
  • drawrect -nr %p 0 1 572 $gettok(%x,%t,165)
  • inc %t
  • }
  • drawline -nr %p 0 1 578 $calc($1 +10) 582 $calc($1 +5) 586 $calc($1 +10) 578 $calc($1 +10)
  • drawfill -nr %p 0 0 582 $calc($1 + 8)
  • drawline -nr %p 0 1 578 $calc($1 + $2 -10) 582 $calc($1 + $2 -5) 586 $calc($1 + $2 -10) 578 $calc($1 + $2 -10)
  • drawfill -nr %p 0 0 582 $calc($1 + $2 -8)
  • }
  • alias -l belote.majlist {
  • var %p = @Belote
  • if ((!$window(%p)) || ($hget(%p,Main) != WaitingRoom)) return
  • var %t = 1, %m = $hfind(BeloteWaitingRoom,^[0-9]+$,0,r), %l
  • while %t <= %m {
  • var %r = $hfind(BeloteWaitingRoom,^[0-9]+$,%t,r), %l = $addtok(%l,$+(%r,:,$hget(BeloteWaitingRoom,%r)),165)
  • inc %t
  • }
  • if ($sock(Belote).mark == Host) {
  • if (%m == 4) ²button %p 48 490 98 100 56 Jouer !
  • elseif (%m == 3) ²unset %p 48 48 490 98 100 56 Jouer !
  • }
  • var %l = $regsubex($sorttok(%l,165,n),/([0-9]+:)/g,)
  • drawtext -nr %p 0 Tahoma 12 39 40 Joueurs
  • ²list %p 9 5 60 110 93 %l
  • }
  • ;***
  • ;Jeu
  • ;***
  • alias -l belote.start {
  • var %p = @Belote
  • if (!$window(%p)) return
  • .belote.say BEGIN $1-
  • }
  • alias -l belote.distribue {
  • var %n = $belote.next, %h = $+(Cartes,%n), %p = @Belote
  • if (!$hget(BeloteGame,Cartes)) {
  • hadd -m BeloteGame Tour $iif($calc($hget(BeloteGame,TourNew) +1) > 4,1,$v1)
  • var %n = $gettok($hget(BeloteGame,PlayersList),$hget(BeloteGame,Tour),32)
  • belote.say * Toutes les cartes ont été distribuées. C'est à %n d'ouvrir le jeu.
  • belote.say ERASEPROP
  • belote.say TOUR %n GO
  • var %a = $hget(BeloteGame,Atout)
  • return
  • }
  • var %actuel = $hget(BeloteGame,%h), %nb = $numtok(%actuel,32), %no = $iif(%nb == 3,2,3)
  • if ($hget(BeloteGame,Atout)) var %no = $calc(8 - %nb)
  • elseif (%nb == 5) {
  • var %c = $gettok($hget(BeloteGame,Cartes),1,32)
  • hadd -m BeloteGame Cartes $deltok($hget(BeloteGame,Cartes),1,32)
  • belote.say * La carte retournée est $belote.desc(%c) !
  • hadd -m BeloteGame NbTour 1
  • if ($left(%c,1) == V) {
  • hadd -m BeloteGame TourNom %n
  • belote.say RETOURNEE %c FORCE $asctime([HH:nn:ss])
  • .timerbelote.force -o 1 3 belote.treat PREND %n %c $right(%c,1)
  • }
  • else {
  • belote.say RETOURNEE %c
  • hdec -m BeloteGame Tour
  • belote.next
  • }
  • return
  • }
  • hadd -m BeloteGame %h %actuel $gettok($hget(BeloteGame,Cartes),$+(1-,%no),32)
  • hadd -m BeloteGame Cartes $deltok($hget(BeloteGame,Cartes),$+(1-,%no),32)
  • var %1 = $hfind(BeloteWaitingRoom,%n,1).data, %2 = $hfind(BeloteWaitingRoom,%n,2).data, %w
  • if (Belote isin %1) var %w = %1
  • elseif (Belote isin %2) var %w = %2
  • if (%w) sockwrite -n %w DONNE $gettok($hget(BeloteGame,%h),$+(-,%no,-),32)
  • .belote.say CARTES %n %no
  • if (%n == $gettok($hget(BeloteGame,PlayersList),1,32)) belote.treat DONNE $gettok($hget(BeloteGame,%h),$+(-,%no,-),32)
  • .timerbelote.distribue -om 1 800 belote.distribue
  • }
  • alias belote.next {
  • if ($hget(BeloteGame,Pause)) hdel BeloteGame Pause
  • if ($1 == -a) hdec -m BeloteGame Tour
  • else hinc -m BeloteGame Tour
  • if ($hget(BeloteGame,Tour) > 4) hadd -m BeloteGame Tour 1
  • var %n = $gettok($hget(BeloteGame,PlayersList),$hget(BeloteGame,Tour),32)
  • if ($isid) return %n
  • elseif ($1 != -a) belote.say TOUR %n
  • }
  • alias -l belote.newtour {
  • var %p = @Belote
  • if (!$window(%p)) return
  • belote.drawtable
  • var %h = Checks CF, %l = 35, %y = 1
  • hadd -m BeloteGame TourTable $hget(BeloteGame,Tour)
  • while %y <= 2 {
  • var %e = $+(%p,$gettok(%h,%y,32)), %y = %y + 1
  • if ($hget(%e,%l)) hdel %e %l
  • }
  • ²efface %p 275 455 150 20
  • tokenize 32 $hget(BeloteGame,PlayersList)
  • if ($numtok($hget(BeloteGame,Cartes),32) < 32) {
  • var %t = 1, %r = $hget(BeloteGame,TourNew) + 1
  • hadd -m BeloteGame Cartes $addtok($hget(BeloteGame,Cartes),$hget(BeloteGame,Retournee),32)
  • while %t <= 4 {
  • if (%r > 4) var %r = 1
  • hadd -m BeloteGame Cartes $addtok($hget(BeloteGame,Cartes),$hget(BeloteGame,$+(Cartes,$gettok($1-,%r,32))),32)
  • inc %t
  • inc %r
  • }
  • }
  • var %r = $r(3,29)
  • hadd -m BeloteGame Cartes $gettok($hget(BeloteGame,Cartes),$+($calc(%r +1),-),32) $gettok($hget(BeloteGame,Cartes),$+(1-,%r),32)
  • belote.say * Les cartes ont été coupées.
  • hadd -m BeloteGame ScoreTable 0 0
  • if ($sock(Belote).mark == Host) belote.say PLIS 0 0
  • hadd -m BeloteGame Plis 0 0
  • if ($hget(BeloteGame,TableRedraw)) ²button %p 300 490 450 105 20 Voir le dernier pli
  • var %l = Belote Atout Go Table Retournee Pause TableDesc OldTable TableRedraw, %t = 1, %m = $numtok(%l,32)
  • while %t <= %m {
  • var %ht = $gettok(%l,%t,32)
  • if ($hget(BeloteGame,%ht)) hdel BeloteGame %ht
  • inc %t
  • }
  • var %cq = $hget(BeloteGame,Cartes)
  • hadd -m BeloteGame Cartes %cq
  • if ($sock(Belote).mark == Host) {
  • if (!$hget(BeloteGame,TourNew)) hadd -m BeloteGame TourNew $r(1,4)
  • else hinc -m BeloteGame TourNew
  • if ($hget(BeloteGame,TourNew) > 4) hadd -m BeloteGame TourNew 1
  • var %r = $hget(BeloteGame,TourNew)
  • hadd -m BeloteGame Tour %r
  • belote.say * C'est $gettok($1-,%r,32) qui distribue !
  • belote.distribue %r
  • }
  • }
  • alias -l belote.newtable {
  • var %p = @Belote
  • if (!$window(%p)) return
  • hadd -m BeloteGame OldTable $hget(BeloteGame,TableDesc)
  • if ($hget(BeloteGame,TableRedraw)) ²button %p 300 490 450 105 20 Voir le dernier pli
  • var %l = Table TableDesc TableRedraw, %m = $numtok(%l,32), %t = 1
  • while %t <= %m {
  • var %g = $gettok(%l,%t,32)
  • if ($hget(BeloteGame,%g)) hdel BeloteGame %g
  • inc %t
  • }
  • var %l = 300 350¥355 195¥230 165¥115 265, %t = 1
  • while %t <= 4 {
  • ²efface %p $gettok(%l,%t,165) 96 96
  • inc %t
  • }
  • }
  • alias -l belote.newtabletemp {
  • if ($hget(BeloteGame,Pause)) hdel BeloteGame Pause
  • belote.say NEWTABLE
  • belote.say TOUR $1
  • belote.say * $1 ouvre.
  • }
  • alias -l belote.drawtable {
  • var %p = @Belote, %d = $²did(%p,50)
  • if (!$window(@Belote)) return
  • ²efface %p 5 40 590 440
  • .²clear %p -k
  • ;d pour DRAW uniquement
  • if ($1 != -d) {
  • var %cq = $hget(BeloteGame,Cartes)
  • hdel -w BeloteGame Carte*
  • hadd -m BeloteGame Cartes %cq
  • if ($hget(BeloteGame,Moi)) hdel BeloteGame Moi
  • tokenize 32 $hget(BeloteGame,PlayersList)
  • drawtext -nr %p 16711680 Tahoma 12 100 365 $1
  • drawtext -nr %p 255 Tahoma 12 $calc(570 - $width($2,Tahoma,12)) 310 $2
  • drawtext -nr %p 16711680 Tahoma 12 297 60 $3
  • drawtext -nr %p 255 Tahoma 12 10 160 $4
  • var %re = $hget(BeloteGame,Carres), %t = 1
  • while %t <= 4 {
  • drawrect -fnr %p 255 1 $gettok(%re,%t,165) 10 10
  • drawrect -nr %p 0 1 $gettok(%re,%t,165) 10 10
  • inc %t
  • }
  • }
  • ²button %p 60 535 40 60 20 Aide
  • ²zone %p 1002 535 65 65 20
  • ²button %p 1003 535 65 65 20 Points
  • ²zone %p 1000 535 340 65 20
  • ²button %p 1001 535 340 65 20 Joueurs
  • .timer -om 1 20 ²edit %p -a 50 5 575 538 20 %d
  • hadd -m @BeloteEdits C50 MaxLength:600 Regex:[^&]+
  • ²button %p 51 545 575 50 20 Envoyer
  • ²setdefault %p 51
  • ²efface %p 5 40 140 85
  • belote.drawscores
  • }
  • alias -l belote.drawscores {
  • var %p = @Belote
  • if (!$window(%p)) return
  • ²efface %p 5 40 171 80
  • drawtext -pnr %p 0 Tahoma 16 65 40 Scores
  • tokenize 32 $hget(BeloteGame,Score)
  • if ($1 > $2) var %b = 1
  • else var %b = 2
  • var %eq = $iif($findtok($hget(BeloteGame,Equipe1),$bel.n,1,165),1,2), %c = Equipe $iif(%b == 1,1,2) : $iif(%b == 1,$1,$2), %d = Equipe $iif(%b == 1,2,1) : $iif(%b == 2,$1,$2)
  • var %a = $gettok(16711680 255-255 16711680,%eq,45)
  • drawtext -nr %p $gettok(%a,%b,32) Tahoma 14 $calc(88 - $width(%c,Tahoma,14) /2) $iif(%t,100,70) %c
  • drawtext -nr %p $deltok(%a,%b,32) Tahoma 14 $calc(88 - $width(%d,Tatoma,14) /2) $iif(%t,70,100) %d
  • }
  • ;**************
  • ;Données du GUI
  • ;**************
  • alias belote.answer
  • alias belote.move belote.closesecond
  • alias belote.mouse {
  • var %p = @Belote
  • if ($3 == ID:1000) belote.winplayers
  • elseif ($3 == ID:1002) belote.winpoints
  • else {
  • var %c, %x
  • if (($inrect($mouse.x,$mouse.y,90,382,182,96)) && ($hget(%p,Main) == Game)) {
  • ;Carte sélectionnée
  • if (!$hget(BeloteGame,Go)) return
  • tokenize 32 $hget(BeloteGame,Moi)
  • var %x = $calc(75+15* $0), %m = $0, %a = $mouse.x
  • while ((%a !isnum $+(%x,-,$calc(%x +72))) && (%m)) var %x = %x - 15, %m = %m - 1
  • if (%m) var %c = $gettok($1-,%m,32)
  • }
  • if (($hget(BeloteConfig,Highlight)) && ($hget(BeloteConfig,Highlight) != %c)) {
  • drawreplace -nr %p 16768220 16777215 90 380 177 96
  • hdel BeloteConfig Highlight
  • }
  • if (%c) {
  • drawreplace -nr %p 16777215 16768220 %x 380 $iif(%m == $0,72 96,15 96)
  • hadd -m BeloteConfig Highlight %c
  • }
  • if ((%p) && (!$hget(BeloteConfig,Draw))) drawdot %p
  • if (!$inrect($mouse.x,$mouse.y,0,0,600,600)) return
  • belote.closesecond
  • }
  • }
  • alias beloteplayers.sclick {
  • var %pp = @BelotePlayers
  • if (($1 == 1) && (!$hget(BeloteConfig,Remplace)) && ($sock(Belote).mark == Host)) {
  • if ((!$istok($hget(BeloteGame,PlayersList),$²did(%pp,1),32)) && ($²did(%pp,1))) ²button %pp 3 20 165 110 20 Remplace
  • else ²unset %pp 3
  • var %l, %m = $hfind(BeloteWaitingRoom,^[0-9]+,0,r), %t = 1
  • while (%t <= %m) var %r = $hfind(BeloteWaitingRoom,^[0-9]+,%t,r), %n = $hget(BeloteWaitingRoom,%r), %l = $addtok(%l,$+($iif($istok($hget(BeloteGame,PlayersList),%n,32),1,2),%r,:,%n),165), %t = %t + 1
  • var %l = $sorttok(%l,165,n), %sp = $wildtok(%l,1*,0,165)
  • hadd -m GUI-ArKanis %pp 1
  • drawline -nr %pp 0 1 20 $calc(41+ %sp *15) 130 $calc(41+ %sp *15)
  • }
  • elseif ($istok(2 3,$1,32)) {
  • var %s = $²did(%pp,1)
  • if ((!%s) || ($sock(Belote).mark != Host)) return
  • if ($1 == 2) {
  • if ($²did(%pp,1).line == 1) return
  • belote.exclure %s
  • ²freehash %pp Buttons BF Lists LF
  • window -c %pp
  • }
  • elseif ($1 == 3) {
  • if ($hget(BeloteConfig,Remplace)) {
  • hdel BeloteConfig Remplace
  • var %n = $v1, %o = %s, %v, %vv, %1 = $hfind(BeloteWaitingRoom,%n,1).data, %2 = $hfind(BeloteWaitingRoom,%n,2).data, %w
  • if (Belote isin %1) var %w = %1
  • elseif (Belote isin %2) var %w = %2
  • var %1 = $hfind(BeloteWaitingRoom,%o,1).data, %2 = $hfind(BeloteWaitingRoom,%o,2).data, %w2
  • if (Belote isin %1) var %w2 = %1
  • elseif (Belote isin %2) var %w2 = %2
  • ;w2 : ancien
  • ;w : nouveau
  • if (!$sock(%w)) unset %w
  • if (!$sock(%w2)) unset %w2
  • belote.say STOPDRAW
  • belote.say CHGCARTES %o %n
  • belote.say CHGEQUIPE $reptok($hget(BeloteGame,Equipe1),%o,%n,1,165) $reptok($hget(BeloteGame,Equipe2),%o,%n,1,165)
  • if ($hget(BeloteGame,$+(Cartes,%o))) {
  • var %v = $v1
  • hadd -m BeloteGame $+(Cartes,%n) $v1
  • hdel BeloteGame $+(Cartes,%o)
  • belote.say SETCARTES %n $numtok(%v,32)
  • }
  • var %r = $+(/(^|\s),$chr(40),%o,$chr(41),:/g), %vv = $regsubex($hget(BeloteGame,TableDesc),%r,$+(\1,%n,:))
  • hadd -m BeloteGame TableDesc %vv
  • var %sim = NEWTABLE¥REDRAWTABLE %vv, %t = 1, %m = $numtok(%sim,165)
  • while %t <= %m {
  • var %g = $gettok(%sim,%t,165)
  • if (%w) sockwrite -n %w %g
  • if (%w2) sockwrite -n %w2 %g
  • if ($istok(%o %n,$bel.n,32)) belote.treat %g
  • inc %t
  • }
  • if ($hget(BeloteGame,Prend) == %o) sockwrite -n %w ATOUT $hget(BeloteGame,Atout) %n
  • elseif (%w) sockwrite -n %w ATOUT $hget(BeloteGame,Atout) $hget(BeloteGame,Prend)
  • belote.say NEWNAMES
  • if (%w) {
  • sockwrite -n %w NEWJEU
  • sockwrite -n %w DONNE %v
  • }
  • if (%n == $bel.n) {
  • belote.treat NEWJEU
  • belote.treat DONNE %v
  • }
  • var %na = $gettok($hget(BeloteGame,PlayersList),$hget(BeloteGame,Tour),32)
  • belote.say TOUR %na
  • belote.say DRAW
  • belote.say * %o a été remplacé par %n
  • ²freehash %pp Buttons BF Lists LF
  • window -c %pp
  • return
  • }
  • elseif ($istok($hget(BeloteGame,PlayersList),%s,32)) return
  • ²centre %pp 10 %s remplacera
  • hadd -m BeloteConfig Remplace %s
  • ²button %pp 3 20 165 110 20 Remplacer
  • ²list %pp 1 20 40 110 93 $replace($hget(BeloteGame,PlayersList),$chr(32),¥)
  • }
  • }
  • if ($window(%pp)) drawdot %pp
  • }
  • alias belote.uclick if ($hget(BeloteConfig,Uclick)) hdel BeloteConfig Uclick
  • alias belote.sclick {
  • if (!$istok(1001 1003,$1,32)) belote.closesecond
  • var %p = @Belote
  • if ($1 == 1) {
  • if ($sock(Belote).ip) {
  • clipboard $+($v1,:,$sock(Belote).port)
  • ²efface %p 115 300 370 20
  • ²centre %p 300 Les paramètres de connexion ont été copiés dans le Presse-Papier.
  • }
  • }
  • elseif ($1 == 2) {
  • if (!$regex($²did(%p,5),^(\w{1,12})$)) ²flash %p 5
  • else {
  • hadd -m BeloteConfig Nom $regml(1)
  • ²clear %p
  • belote.waitingroom $regml(1)
  • }
  • }
  • elseif ($1 == 3) {
  • var %ip = $²did(%p,4), %t
  • if (!$regex(%ip,^([0-9]+\.[0-9]+\.[0-9]+\.[0-9]+):([0-9]+)$)) {
  • var %t = 1
  • ²flash %p 2
  • }
  • else var %ip = $regml(1), %q = $regml(2)
  • if (!$regex($²did(%p,5),^(\w{1,12})$)) {
  • var %t = 1
  • ²flash %p 5
  • }
  • else var %nom = $regml(1)
  • if (!%t) {
  • ²clear %p
  • hadd -m %p Main Joining
  • hadd -m BeloteConfig Nom %nom
  • ²centre %p 100 Connexion au serveur %ip en cours ...
  • sockclose Belote*
  • sockopen Belote %ip %q
  • }
  • }
  • elseif ($istok(6 7,$1,32)) {
  • ²clear %p
  • if ($1 == 6) belote.host
  • else belote.join
  • }
  • elseif ($1 == 48) {
  • if ($hget(BeloteGame,Temp)) return
  • var %a1 = $²did(%p,52).chx, %a2 = $²did(%p,53).chx, %t = 1, %m = $hfind(BeloteWaitingRoom,^[0-9]+$,0,r), %l
  • if (%m < 4) {
  • belote.disp * Impossible de lancer la partie : pas assez de joueurs.
  • return
  • }
  • while %t <= %m {
  • var %r = $hfind(BeloteWaitingRoom,^[0-9]+$,%t,r), %q = $hget(BeloteWaitingRoom,%r)
  • if ((!$istok(%a1,%q,165)) && (!$istok(%a2,%q,165))) var %l = $addtok(%l,$+(%r,:,%q),165)
  • inc %t
  • }
  • var %l = $regsubex($sorttok(%l,165,n),/([0-9]+:)/g,)
  • while ($numtok(%a1,165) != 2) var %a1 = $addtok(%a1,$gettok(%l,1,165),165), %l = $deltok(%l,1,165)
  • while ($numtok(%a2,165) != 2) var %a2 = $addtok(%a2,$gettok(%l,1,165),165), %l = $deltok(%l,1,165)
  • .timerbelote.start -o 1 3 belote.start %a1 VS %a2
  • belote.say * Le jeu commence dans trois secondes !
  • hadd -mu3 BeloteGame Temp 1
  • }
  • elseif ($1 == 49) {
  • if ($sock(Belote).mark != Host) return
  • var %s = $²did(%p,9), %l = $²did(%p,9).line
  • if ((!%s) || (%l == 1)) return
  • belote.exclure %s
  • }
  • elseif ($1 == 51) {
  • var %q = $²did(%p,50)
  • if ((!%q) || (!$sock(Belote))) return
  • ²edit %p 50 5 575 538 20
  • if ($sock(Belote).mark == Host) belote.say SAY $bel.n : %q
  • else belote.say SAY %q
  • }
  • elseif ($istok(54 55,$1,32)) {
  • if ($sock(Belote).mark != Host) return
  • var %s = $²did(%p,9), %a1 = $²did(%p,52).chx, %a2 = $²did(%p,53).chx, %b1 = %a1, %b2 = %a2, %d
  • if ($istok(%a1,%s,165)) var %b1 = $remtok(%a1,%s,1,165), %d = 1
  • if ($istok(%a2,%s,165)) var %b2 = $remtok(%a2,%s,1,165), %d = 1
  • if (!%d) {
  • if (($1 == 54) && ($numtok(%b1,165) < 2)) var %b1 = $addtok(%b1,%s,165)
  • elseif (($1 == 55) && ($numtok(%b2,165) < 2)) var %b2 = $addtok(%b2,%s,165)
  • }
  • .belote.say EQUIPE 1 %b1
  • .belote.say EQUIPE 2 %b2
  • }
  • elseif ($1 == 59) {
  • var %l = $hget(BeloteGame,Moi), %s = PCTK, %c
  • if ($regex($hget(BeloteGame,Atout),^([PCTK])$)) {
  • var %a = $regml(1)
  • while ($right(%s,1) != %a) var %s = $+($right(%s,1),$left(%s,3))
  • }
  • while $left(%s,1) {
  • var %k = $v1, %r = /([01789DRVA]{1,2}) $+ %k $+ /g, %i = 1, %d
  • if (%k == %a) var %or = 7 8 D R 10 A 9 V
  • else var %or = 7 8 9 V D R 10 A
  • noop $regex(%l,%r)
  • var %i = 1
  • while $regml(%i) {
  • var %j = 1, %ins = $v1
  • while %j <= %i {
  • var %ac = $findtok(%or,$gettok(%d,%j,32),1,32), %ad = $findtok(%or,%ins,1,32)
  • if ((%ac > %ad) || (!%ac)) {
  • var %d = $instok(%d,%ins,%j,32)
  • break
  • }
  • inc %j
  • }
  • inc %i
  • }
  • var %c = $addtok(%c,$regsubex(%d,/([01789DRVA]{1,2})/g,$+(\1,%k)),32), %s = $right(%s,-1)
  • }
  • hadd -m BeloteGame Moi %c
  • belote.drawcartes -e
  • }
  • elseif ($1 == 60) belote.aide
  • elseif ($istok(61 62,$1,32)) {
  • if (!$sock(Belote)) return
  • var %q = $findtok($hget(BeloteGame,PlayersList),$hget(BeloteGame,TourNom),1,32)
  • if (%q == 1) {
  • var %co = $gettok(P C T K,$findtok(Pique Coeur Trèfle Carreau,$²did(%p,111).seltext,1,32),32)
  • if ($sock(Belote).mark == Host) belote.treat $iif($1 == 61,PASSE,PREND) $bel.n %co
  • else belote.say $iif($1 == 61,PASSE,PREND) $bel.n %co
  • }
  • else belote.disp * Ce n'est pas votre tour !
  • }
  • elseif ($1 == 100) {
  • if ($regex($²did(%p,101),^(\w{1,12})$)) {
  • writeini -n $bel.i Config Pseudo $regml(1)
  • hadd -m BeloteConfig Pseudo $regml(1)
  • }
  • if ($regex($²did(%p,102),^([0-9]{1,6})$)) writeini -n $bel.i Config Port $regml(1)
  • ²centre %p 554 Configuration sauvegardée !
  • }
  • elseif ($1 == 200) {
  • if ($sock(Belote).mark != Host) return
  • belote.say BEGIN $hget(BeloteGame,Equipe1) VS $hget(BeloteGame,Equipe2)
  • }
  • elseif ($1 == 201) belote.host
  • elseif ($1 == 300) {
  • if ($hget(BeloteGame,TableRedraw)) {
  • hdel BeloteGame TableRedraw
  • belote.redrawtable $hget(BeloteGame,TableDesc)
  • ²button %p -s 300 490 450 105 20 Voir le dernier pli
  • }
  • else {
  • hadd -m BeloteGame TableRedraw 1
  • belote.redrawtable $hget(BeloteGame,OldTable)
  • ²button %p -s 300 490 450 105 20 Revenir au jeu
  • }
  • }
  • elseif (($inrect($mouse.x,$mouse.y,90,382,182,96)) && ($hget(%p,Main) == Game)) {
  • ;Carte sélectionnée
  • if (!$hget(BeloteGame,Go)) return
  • tokenize 32 $hget(BeloteGame,Moi)
  • var %x = $calc(75+15* $0), %m = $0, %a = $mouse.x
  • while ((%a !isnum $+(%x,-,$calc(%x +72))) && (%m)) var %x = %x - 15, %m = %m - 1
  • if (%m) {
  • var %c = $gettok($1-,%m,32)
  • if (%c) {
  • if ($sock(Belote).mark == Host) belote.treat JOUER $bel.n %c $iif($²did(%p,35),BELOTE)
  • else belote.say JOUER $bel.n %c $iif($²did(%p,35),BELOTE)
  • }
  • }
  • }
  • elseif (($inrect($mouse.x,$mouse.y,572,$iif($hget(%p,Main) == Game,486,166),20,$iif($hget(%p,Main) == Game,83,403))) && ($istok(WaitingRoom Game,$hget(%p,Main),32))) {
  • hadd -m BeloteConfig Uclick 1
  • .timerbelote.lift -m 1 500 belote.drawlifter
  • belote.drawlifter
  • }
  • elseif ($1 == 1001) {
  • if ($hget(BeloteConfig,WinPlayers)) {
  • if ($window(@BelotePlayers)) window -c $v1
  • hdel BeloteConfig WinPlayers
  • }
  • else {
  • hadd -m BeloteConfig WinPlayers 1
  • belote.winplayers
  • }
  • }
  • elseif ($1 == 1003) {
  • if ($hget(BeloteConfig,WinPoints)) {
  • if ($window(@BelotePoints)) window -c $v1
  • hdel BeloteConfig WinPoints
  • }
  • else {
  • hadd -m BeloteConfig WinPoints 1
  • belote.winpoints
  • }
  • }
  • if (($window(%p)) && (!$hget(BeloteConfig,Draw))) drawdot %p
  • }
  • alias belote.edit {
  • var %p = @Belote
  • if (!$window(%p)) return
  • if ($hget(%p,Main) == belote.config) ²efface %p 200 554 200 20
  • }
  • alias belote.close {
  • sockclose Belote*
  • .timerbelote* off
  • ²freehash Belote WaitingRoom Config
  • var %w = Temp Dos Cartes Convers, %t = 1
  • while %t <= 4 {
  • if ($window($gettok($+(@Belote,%w),%t,32))) window -c $v1
  • inc %t
  • }
  • if ($window(@BeloteWinPlayers)) window -v $v1
  • if ($window(@BeloteWinPoints)) window -v $v1
  • }
  • ;*********
  • ;Ascenseur
  • ;*********
  • alias belote.drawlifter {
  • var %x = $mouse.x, %y = $mouse.y, %p = @Belote
  • if ((!$window(%p)) || (!$hget(BeloteConfig,Uclick))) return
  • if ($hget(%p,Main) == Game) var %q = 486 83
  • else var %q = 166 403
  • tokenize 32 %q
  • var %o = $hget(BeloteConfig,Lifter)
  • if ($inrect(%x,%y,572,$1,20,15)) hinc BeloteConfig Lifter 2
  • elseif ($inrect(%x,%y,572,$calc($1 + $2 -15),20,15)) hdec BeloteConfig Lifter 2
  • elseif ($getdot(%p,%x,%y) != 16742520) {
  • if (%y < $hget(BeloteConfig,LifterPos)) hinc BeloteConfig Lifter 4
  • else hdec BeloteConfig Lifter 4
  • }
  • else return
  • .timerbelote.lift -m 1 500 belote.drawlifter
  • belote.drawtext -e %q
  • drawdot %p
  • }
  • ;****
  • ;Aide
  • ;****
  • alias belote.aide {
  • var %pp = @BeloteAide
  • if ($window(%pp)) {
  • beloteaide.close
  • return
  • }
  • ²picwin %pp 400 500 "Aide de la Belotte"
  • window -ao %pp
  • ²newmenu %pp Fichier
  • ²newitem %pp Points:beloteaide.points,Règles:beloteaide.regles,$chr(9),Fermer:beloteaide.close
  • .timer -m 1 1 beloteaide.disp
  • }
  • alias beloteaide.disp {
  • var %pp = @BeloteAide
  • if (!$window(%pp)) return
  • ²drawmenu %pp 1 1
  • drawdot %pp
  • }
  • alias beloteaide.sclick return
  • alias beloteaide.close {
  • var %pp = @BeloteAide
  • if (!$window(%pp)) return
  • ²close %pp cash
  • window -c %pp
  • }
  • alias beloteaide.points {
  • var %pp = @BeloteAide
  • if (!$window(%pp)) return
  • ²centre %pp -b 40 Points
  • var %d = drawtext -pnr %pp 0 Tahoma 12
  • %d 10 60 Points des Atout :
  • %d 200 60 Points des cartes Normales :
  • var %t = 1, %l = Valet 9 As 10 Roi Dame 8 7, %m = 20 14 11 10 4 3 0 0, %n = As 10 Roi Dame Valet 9 8 7, %o = 11 10 4 3 2 0 0 0
  • while %t <= 8 {
  • %d 10 $calc(60+20* %t) $gettok(%l,%t,32)
  • %d 90 $calc(60+20* %t) $gettok(%m,%t,32)
  • %d 200 $calc(60+20* %t) $gettok(%n,%t,32)
  • %d 280 $calc(60+20* %t) $gettok(%o,%t,32)
  • inc %t
  • }
  • %d 10 270 Points de la belote/rebelote : 20
  • %d 10 290 Il faut avoir le roi et la dame d'atout et annoncer belote au premier,
  • %d 10 310 rebelote au deuxième
  • %d 10 340 Il faut 80 points pour faire la partie, 81 donne litige.
  • %d 10 360 Un litige donne 80 points à l'équipe n'ayant pas pris et remet les
  • %d 10 380 les 80 autres pour la partie suivante.
  • %d 10 410 Un retourné donne 160, capot 250.
  • drawdot %pp
  • }
  • alias beloteaide.regles {
  • var %pp = @BeloteAide
  • if (!$window(%pp)) return
  • ²centre %pp -b 40 Règles
  • var %e = drawtext -pnr %pp 0 Tahoma 11, %d = %e 10
  • %d 60 La belote se joue en équipe. Les coéquipiers seront toujours face à face.
  • %d 80 Elle se joue dans le sens inverse des aiguilles d'une montre.
  • %d 100 Un tour commence par la distribution des cartes de la méthode suivante :
  • %e 20 120 Trois cartes sont données à tout le monde, puis deux.
  • %e 20 140 La carte du dessus est ensuite retournée, et c'est au premier à droite
  • %e 40 160 de celui qui distribue qui dit s'il prend ou pas.
  • %d 180 Si la carte retournée est un atout, alors le suivant est obligé de prendre
  • %d 200 Prendre au premier tour signifie que la couleur de l'atout sera la couleur
  • %e 20 220 de la carte du milieu. Le preneur ramasse alors la carte du milieu
  • %e 20 240 et la met dans son jeu.
  • %d 260 Si personne ne prend au premier tour (passe), alors vous aurez le choix
  • %e 20 280 de la couleur au second (excepté la couleur de la carte retournée).
  • %d 300 Si personne ne prend au second tour, les cartes sont ramassées dans l'ordre
  • %e 20 320 et on recommence la distribution après avoir coupé les cartes.
  • %d 340 Dès que quelqu'un prend, que ce soit au premier ou au deuxième tour,
  • %e 20 360 la distribution reprend dans l'ordre en donnant trois cartes à chacun
  • %e 20 380 sauf au preneur qui n'en prend que deux.
  • %d 400 La stratégie veut souvent que le preneur (qui a en temps normal plus d'atouts
  • %e 40 420 que les autres) fasse tomber les atouts. Il joue le Valet s'il l'a
  • %e 40 440 mais ne risquera pas le Neuf.
  • %d 460 Le but est de faire le plus de points possible. Celui qui prend doit faire
  • %e 20 480 plus que la moitié : 82 sur 162 points sinon il se fait retourner.
  • drawdot %pp
  • }
  • ;*******************
  • ;Changement d'équipe
  • ;*******************
  • alias -l belote.chgequipe {
  • var %p = @Belote
  • if (!$window(%p)) return
  • hadd -m BeloteGame OldCarres $hget(BeloteGame,Carres)
  • var %l = $hget(BeloteGame,PlayersList)
  • ²efface %p 100 365 $width($gettok(%l,1,32),Tahoma,12) 15
  • ²efface %p $calc(570 - $width($gettok(%l,2,32),Tahoma,12)) 310 $width($gettok(%l,2,32),Tahoma,12) 15
  • ²efface %p 297 60 $width($gettok(%l,3,32),Tahoma,12) 15
  • ²efface %p 10 160 $width($gettok(%l,4,32),Tahoma,12) 15
  • hadd -m BeloteGame Equipe1 $1
  • hadd -m BeloteGame Equipe2 $2
  • tokenize 32 $gettok($1,1,165) $gettok($2,1,165) $gettok($1,2,165) $gettok($2,2,165)
  • var %f = $findtok($1-,$bel.n,1,32)
  • if (%f) tokenize 32 $gettok($1-,$+(%f,-),32) $iif(%f != 1,$gettok($1-,$+(1-,$calc(%f -1)),32))
  • hadd -m BeloteGame PlayersList $1-
  • hadd -m BeloteGame Carres $calc(105+ $width($1,Tahoma,12)) 368¥575 313¥ $calc(302+ $width($3,Tahoma,12)) 63¥ $calc(15+ $width($4,Tahoma,12)) 163
  • }
  • alias -l belote.newnames {
  • var %p = @Belote
  • if (!$window(%p)) return
  • var %t = 1, %q = $hget(BeloteGame,OldCarres), %nq = $hget(BeloteGame,Carres)
  • while %t <= 4 {
  • ²efface %p $gettok(%q,%t,165) 10 10
  • drawrect -fnr %p 255 1 $gettok(%nq,%t,165) 10 10
  • drawrect -nr %p 0 1 $gettok(%nq,%t,165) 10 10
  • inc %t
  • }
  • tokenize 32 $hget(BeloteGame,PlayersList)
  • drawtext -nr %p 16711680 Tahoma 12 100 365 $1
  • drawtext -nr %p 255 Tahoma 12 $calc(570 - $width($2,Tahoma,12)) 310 $2
  • drawtext -nr %p 16711680 Tahoma 12 297 60 $3
  • drawtext -nr %p 255 Tahoma 12 10 160 $4
  • }
  • alias -l belote.redrawcartes {
  • var %s = 72 96, %f = $1, %p = @Belote
  • if (!$window(%p)) return
  • if ((%f == 1) && ($bel.player)) return
  • if (!$window(@BeloteDos)) window -Bphk0g0 @BeloteDos 96 96
  • drawpic -cnr @BeloteDos 0 0 $bel.f(dos.png)
  • if ($istok(2 4,%f,32)) {
  • var %s = 96 72
  • drawrot -n @BeloteDos 90 0 0 96 96
  • }
  • var %h = $+(Carte,$2), %o = $iif($hget(BeloteGame,%h),$v1,1), %x, %y
  • var %ox = $gettok(90 499 219 5,%f,32), %oy = $gettok(382 235 44 180,%f,32)
  • if ($3) hinc -m BeloteGame %h $3
  • else var %o = 1
  • if ($3 == -1) {
  • var %q = $calc($hget(BeloteGame,%h) +1)
  • if (%f == 1) var %x = $calc(5+ %q *5)
  • elseif (%f == 2) var %y = $calc(5- %q *5)
  • elseif (%f == 3) var %x = $calc(5- %q *5)
  • else var %y = $calc(%q *5-5)
  • ²efface %p $calc(%ox + %x) $calc(%oy + %y) $iif($calc(%f % 2),72 96,96 72)
  • var %o = $hget(BeloteGame,%h)
  • }
  • if (%o) {
  • while %o <= $hget(BeloteGame,%h) {
  • if (%f == 1) var %x = $calc(5+ %o *5)
  • elseif (%f == 2) var %y = $calc(5- %o *5)
  • elseif (%f == 3) var %x = $calc(5- %o *5)
  • else var %y = $calc(%o *5-5)
  • drawcopy -nrt @BeloteDos 16777215 0 0 %s %p $calc(%ox + %x) $calc(%oy + %y)
  • inc %o
  • }
  • }
  • }
  • ;**************
  • ;Aliases divers
  • ;**************
  • alias -l bel.i return $bel.f(belote.ini)
  • alias -l bel.f return $+(Belote\,$1-)
  • alias -l bel.n {
  • var %l = $hget(BeloteConfig,Nom) $me, %t = 1, %n
  • while $gettok(%l,%t,32) {
  • var %q = $v1
  • if ($regex(%q,^(\w{1,12})$)) {
  • var %n = %q
  • break
  • }
  • inc %t
  • }
  • if (!%n) var %n = $+(Joueur,$r(1,999))
  • hadd -m BeloteConfig Nom %n
  • return %n
  • }
  • alias -l belote.desc {
  • if (!$1) return
  • var %d = le¥, %n
  • if (D isin $1) var %d = la¥
  • elseif (A isin $1) var %d = l'
  • var %n = $gettok(Sept Huit Neuf Valet Dame Roi Dix As,$findtok(7 8 9 V D R 10 A,$left($1,-1),1,32),32)
  • return $replace($+(%d,%n),¥,$chr(32)) de $gettok(Pique Trèfle Coeur Carreau,$findtok(P T C K,$right($1,1),1,32),32)
  • }
  • alias -l belote.drawcartes {
  • var %p = @Belote, %a
  • if (!$window(%p)) return
  • if ($left($1,1) == -) {
  • if (e isin $1) ²efface %p 90 382 177 96
  • tokenize 32 $2-
  • }
  • var %l = $hget(BeloteGame,Moi), %t = $iif($1 isnum,$v1,1), %m = $numtok(%l,32)
  • while %t <= %m {
  • var %c = $gettok(%l,%t,32), %q = $belote.pos(%c)
  • belote.drawcarte 1 $calc(90+15* $calc(%t -1)) 382 %c
  • inc %t
  • }
  • }
  • alias -l belote.drawcarte {
  • var %p = @Belote, %ticks = $ticks
  • if (!$window(%p)) return
  • if (!$4) return
  • if ($window(@BeloteCartes).w $window(@BeloteCartes).h != 583 390) {
  • if ($window(@BeloteText)) window -c @BeloteText
  • window -Bdhpnk0g0 +dL @BeloteText 0 0 150 150
  • drawrect -fnr @BeloteText 16777215 1 0 0 150 150
  • drawtext -nr @BeloteText 0 Tahoma 12 $iif($1,30,1) 1 $4
  • if ($1) drawrot -n @BeloteText -90 0 0 150 150
  • var %wx = 1 $2-3 $iif($1,72 96,96 72) 5 5
  • drawrect -fnrd %p 16777215 %wx
  • drawrect -nrd %p 0 %wx
  • drawcopy -nt @BeloteText 16777215 2 2 $iif($1,20 145,145 20) %p $calc($2 + 2) $calc($3 + 2 + $iif($1,$calc(-92+ $width($4,Tahoma,12))))
  • window -c @BeloteText
  • }
  • else {
  • if ($window(@BeloteTemp)) drawrect -fnr $v1 16777215 1 0 0 96 96
  • else window -Bphk0g0 @BeloteTemp 96 96
  • var %s = 72 96
  • drawcopy -nr @BeloteCartes $belote.pos($4) 72 96 @BeloteTemp 0 0
  • if (!$1) {
  • var %s = 96 72
  • drawrot -n @BeloteTemp 90 0 0 96 96
  • }
  • drawcopy -nr @BeloteTemp 0 0 %s %p $2-3
  • }
  • }
  • alias -l belote.redrawtable {
  • var %p = @Belote
  • if (!$window(%p)) return
  • if ($hget(BeloteGame,Retournee)) belote.drawcarte 1 260 215 $v1
  • else {
  • var %l = $1-, %t = 1
  • noop $regex(%l,^([^:]+):)
  • var %n = $regml(1), %ff = $findtok($hget(BeloteGame,PlayersList),%n,1,32)
  • if (!%ff) var %ff = 1
  • while %t <= 4 {
  • var %a = $iif($istok(2 4,%ff,32),0,1) $gettok(300 350¥355 195¥230 165¥115 265,%ff,165), %c = $gettok($gettok(%l,%t,32),2,58)
  • if (%c) belote.drawcarte %a %c
  • else ²efface %p $gettok(%a,2-,32) $iif($istok(2 4,%ff,32),96 72,72 96)
  • var %t = %t + 1, %ff = %ff + 1
  • if (%ff > 4) var %ff = 1
  • }
  • }
  • }
  • ;****************
  • ;Fenêtres collées
  • ;****************
  • on *:active:*:{
  • if ($istok(@BelotePlayers @BelotePoints,$active,32)) return
  • if (($istok(@BelotePlayers @BelotePoints,$lactive,32)) && ($active == @Belote)) return
  • belote.closesecond FORCE
  • }
  • alias belote.closesecond {
  • if (($window(@BelotePlayers)) && ((!$hget(BeloteConfig,WinPlayers)) || ($1) || ($hget(@Belote,Main) != Game))) {
  • if ($hget(BeloteConfig,WinPlayers)) hdel BeloteConfig WinPlayers
  • window -c @BelotePlayers
  • }
  • if (($window(@BelotePoints)) && ((!$hget(BeloteConfig,WinPoints)) || ($1) || ($hget(@Belote,Main) != Game))) {
  • if ($hget(BeloteConfig,WinPoints)) hdel BeloteConfig WinPoints
  • window -c @BelotePoints
  • }
  • }
  • on *:appactive:belote.closesecond FORCE
  • alias -l belote.winplayers {
  • var %pp = @BelotePlayers, %p = @Belote
  • if ($window(%pp)) return
  • window -hBdpg0k0 +dL %pp $calc($window(@Belote).x + 599) $calc($window(@Belote).y + 300) 150 200
  • window -ao %pp
  • window -a %p
  • drawrect -nr %pp 15762050 1 1 1 148 198
  • drawrect -nr %pp 0 1 0 0 150 200
  • if ($hget(BeloteConfig,Remplace)) hdel BeloteConfig Remplace
  • beloteplayers.maj
  • drawdot %pp
  • }
  • alias -l belote.winpoints {
  • var %pp = @BelotePoints, %p = @Belote
  • if ($window(%pp)) return
  • window -hBdopg0k0 +dL %pp $calc($window(@Belote).x + 599) $calc($window(@Belote).y + 50) 150 185
  • window -ao %pp
  • window -a %p
  • drawrect -nr %pp 15762050 1 1 1 148 183
  • drawrect -nr %pp 0 1 0 0 150 185
  • ²efface %pp 0 2 148 181
  • var %d = drawtext -pnr %pp 0 Tahoma 11
  • %d 5 5 Atout
  • %d 5 25 V : 20 Pts
  • %d 5 45 9 : 14 Pts
  • %d 5 65 A : 11 Pts
  • %d 5 85 10 : 10 Pts
  • %d 5 105 R : 4 Pts
  • %d 5 125 D : 3 Pts
  • %d 5 145 8 : 0 Pt
  • %d 5 165 7 : 0 Pt
  • %d 80 5 Non Atout
  • %d 80 25 A : 11 Pts
  • %d 80 45 10 : 10 Pts
  • %d 80 65 R : 4 Pts
  • %d 80 85 D : 3 Pts
  • %d 80 105 V : 2 Pts
  • %d 80 125 9 : 0 Pt
  • %d 80 145 8 : 0 Pt
  • %d 80 165 7 : 0 Pt
  • drawdot %pp
  • }
  • alias -l beloteplayers.maj {
  • var %pp = @BelotePlayers
  • if (!$window(%pp)) return
  • ²efface %pp 0 2 148 196
  • var %l, %m = $hfind(BeloteWaitingRoom,^[0-9]+,0,r), %t = 1
  • while (%t <= %m) var %r = $hfind(BeloteWaitingRoom,^[0-9]+,%t,r), %n = $hget(BeloteWaitingRoom,%r), %l = $addtok(%l,$+($iif($istok($hget(BeloteGame,PlayersList),%n,32),1,2),%r,:,%n),165), %t = %t + 1
  • var %l = $sorttok(%l,165,n), %sp = $wildtok(%l,1*,0,165)
  • hadd -m GUI-ArKanis %pp 1
  • ²list %pp 1 20 40 110 93 $regsubex(%l,/([0-9]+:)/g,)
  • drawline -nr %pp 0 1 20 $calc(41+ %sp *15) 130 $calc(41+ %sp *15)
  • if ($sock(Belote).mark == Host) {
  • ²button %pp 2 20 140 110 20 Exclure
  • ²button %pp 3 20 165 110 20 Remplace
  • ²unset %pp 3
  • }
  • else hadd -m @BeloteLists C1 NoSel
  • }
  • alias -l belote.exclure {
  • if (!$window(@Belote)) exit
  • var %s = $1, %1 = $hfind(BeloteWaitingRoom,%s,1).data, %2 = $hfind(BeloteWaitingRoom,%s,2).data, %w
  • if (Belote isin %1) var %w = %1
  • elseif (Belote isin %2) var %w = %2
  • if (!%w) return
  • hadd -m BeloteBlack $sock(%w).ip 1
  • sockwrite -n %w BAN
  • sockclose %w
  • belote.say * %s a été banni
  • belote.say PART %s
  • }
  • ;End Of File
;****************
;     Belote
;   By ArKanis
; www.arkanis.eu
;****************

alias bel.v return 1.21

alias belote {
  if (!$isdir(Belote)) mkdir Belote
  sockclose belDL
  sockopen belDL arkanisfr.free.fr 80
  if (!$isalias(²picwin)) {
    if ($findfile($mircdir,GUI-ArKanis.mrc,1)) .load -rs $qt($v1)
    else {
      echo 2 -at * Le code va tenter de télécharger les fichiers nécessaires.
      return
    }
  }
}
alias -l belote.open {
  var %p = @Belote
  if (!$isalias(²picwin)) {
    echo 2 -at * Une erreur semble s'être introduite pendant le téléchargement. Veuillez retaper /belote pour retélécharger le code.
    return
  }
  ²picwin %p 600 600 "Belote codée par ArKanis"
  ²newmenu %p Fichier
  ²newitem %p Héberger une partie:belote.host,Rejoindre une partie:belote.join,$chr(9),Configuration:belote.config,$chr(9),Fermer:²close %p
  ²newmenu %p Aide
  ²newitem %p Règles et points:.belote.aide,A Propos:belote.about,$chr(9),Désinstaller:belote.uninstall
  ²drawmenu %p 2 2
  drawdot %p
}

on *:load:echo 2 -at * Merci d'avoir chargé ce script. Tapez /belote pour procéder au téléchargement.
menu status,channel,query,menubar {
  Belote:belote
}

alias belote.uninstall {
  if (!$?!="Voulez-vous procéder à la désinstallation de la