Grafische Benutzeroberflächen (GUI) mit Perl/Tk

Memory-Spiel in Perl/Tk

Der Nutzer Rübezahl hat im PerlUnity-Forum ein Skript zum Memory-Spielen in Perl/Tk gepostet. Wer sich ein bsschen die Zeit vertreiben möchte kann sich entweder 9 Grafiken beschaffen und Memory spielen, oder den Quellcode weiterentwickeln.

Memory-Spiel in Perl/Tk

#! /usr/bin/perl -w

# Fragen und Anregungen an: olaf_rad@web.de

use strict;
use Tk;

my %kartenwert = ();
my %zaehler = ();
my %bildvari = ();
my %schalter = ();
my $zuweisung = undef;
my $mw = undef;

# An dieser Stelle können sie bestimmen welche Bilddatein für
# das Spiel verwendet werden. Tauschen sie den Namen zwischen
# den Anfürungszeichen aus.z.B.:
# my $a = "derNameIhrerDatei.gif";
# Es können nur Bilddatein im GIF-Format benutzt werden

my $a = "memory_a.gif";
my $b = "memory_b.gif";
my $c = "memory_c.gif";
my $d = "memory_d.gif";
my $e = "memory_e.gif";
my $f = "memory_f.gif";
my $g = "memory_g.gif";
my $h = "memory_h.gif";
my $deckblatt = "memory_deckblatt.gif"; # Heir wird das Deckblatt festgelegt
my @kartenliste;
my $zufall;
my $karte;
my $argument;
my $arg1;
my $zustand = 0;
my $erstes_symbol;
my $erste_karte;
my $zweites_symbol;
my $zweite_karte;
my $erstes_argument;
my $zweites_argument;
my $paare_zaehlen = 0;
my $versuche_zaehlen = 0;

karten_mischen();

$mw =MainWindow->new;

my $test = $mw->Photo(-file => $deckblatt);
my $bild1 = $mw->Photo(-file => "$kartenwert{1}");
my $bild2 = $mw->Photo(-file => "$kartenwert{2}");
my $bild3 = $mw->Photo(-file => "$kartenwert{3}");
my $bild4 = $mw->Photo(-file => "$kartenwert{4}");
my $bild5 = $mw->Photo(-file => "$kartenwert{5}");
my $bild6 = $mw->Photo(-file => "$kartenwert{6}");
my $bild7 = $mw->Photo(-file => "$kartenwert{7}");
my $bild8 = $mw->Photo(-file => "$kartenwert{8}");
my $bild9 = $mw->Photo(-file => "$kartenwert{9}");
my $bild10 = $mw->Photo(-file => "$kartenwert{10}");
my $bild11 = $mw->Photo(-file => "$kartenwert{11}");
my $bild12 = $mw->Photo(-file => "$kartenwert{12}");
my $bild13 = $mw->Photo(-file => "$kartenwert{13}");
my $bild14 = $mw->Photo(-file => "$kartenwert{14}");
my $bild15 = $mw->Photo(-file => "$kartenwert{15}");
my $bild16 = $mw->Photo(-file => "$kartenwert{16}");

my $schalter1 = $mw->Button(-image => $test,
    -command => [\&spiel, 1],
    -height => 100,
    -width => 100)->grid(
my $schalter2 = $mw->Button(-image => $test,
    -command => [\&spiel, 2],
    -height => 100,
    -width => 100),
my $schalter3 = $mw->Button(-image => $test,
    -command => [\&spiel, 3],
    -height => 100,
    -width => 100),
my $schalter4 = $mw->Button(-image => $test,
    -command => [\&spiel, 4],
    -height => 100,
    -width => 100));
my $schalter5 = $mw->Button(-image => $test,
    -command => [\&spiel, 5],
    -height => 100,
    -width => 100)->grid(
my $schalter6 = $mw->Button(-image => $test,
    -command => [\&spiel, 6],
    -height => 100,
    -width => 100),
my $schalter7 = $mw->Button(-image => $test,
    -command => [\&spiel, 7],
    -height => 100,
    -width => 100),
my $schalter8 = $mw->Button(-image => $test,
    -command => [\&spiel, 8],
    -height => 100,
    -width => 100));
my $schalter9 = $mw->Button(-image => $test,
    -command => [\&spiel, 9],
    -height => 100,
    -width => 100)->grid(
my $schalter10 = $mw->Button(-image => $test,
    -command => [\&spiel, 10],
    -height => 100,
    -width => 100),
my $schalter11 = $mw->Button(-image => $test,
    -command => [\&spiel, 11],
    -height => 100,
    -width => 100),
my $schalter12 = $mw->Button(
    -image => $test,
    -command => [\&spiel, 12],
    -height => 100,
    -width => 100));
my $schalter13 = $mw->Button(
    -image => $test,
    -command => [\&spiel, 13],
    -height => 100,
    -width => 100)->grid(
my $schalter14 = $mw->Button(
    -image => $test,
    -command => [\&spiel, 14],
    -height => 100,
    -width => 100),
my $schalter15 = $mw->Button(
    -image => $test,
    -command => [\&spiel, 15],
    -height => 100,
    -width => 100),
my $schalter16 = $mw->Button(
    -image => $test,
    -command => [\&spiel, 16],
    -height => 100,
    -width => 100));

my $weiter = $mw->Button(
    -text => "neues Spiel",
    -background => 'yellow',
    -command => sub {exec ("perl ./memory.pl")},
    -height => 5,
    -width => 10)->grid(
my $ende = $mw->Button(
    -bitmap => 'error',
    -background => 'red',
    -command => sub { exit },
    -height => 30,
    -width => 30),
my $info = $mw->Label(
    -text => "Los geht's!")
);
MainLoop();

sub spiel{

##########der hash wid gebraucht für den Aufruf "->configure(-image =>"

%schalter = (
    1 => $schalter1,
    2 => $schalter2,
    3 => $schalter3,
    4 => $schalter4,
    5 => $schalter5,
    6 => $schalter6,
    7 => $schalter7,
    8 => $schalter8,
    9 => $schalter9,
    10 => $schalter10,
    11 => $schalter11,
    12 => $schalter12,
    13 => $schalter13,
    14 => $schalter14,
    15 => $schalter15,
    16 => $schalter16,
);

#########der hash wid gebraucht für den Aufruf "->configure(-image =>"

%bildvari = (
    1 => $bild1,
    2 => $bild2,
    3 => $bild3,
    4 => $bild4,
    5 => $bild5,
    6 => $bild6,
    7 => $bild7,
    8 => $bild8,
    9 => $bild9,
    10 => $bild10,
    11 => $bild11,
    12 => $bild12,
    13 => $bild13,
    14 => $bild14,
    15 => $bild15,
    16 => $bild16
);
# das argument des subrotienenaufrufes wir übergeben
($arg1) = @_;

########################################################
#sind zwei karten aufgedeckt dann...

if ( $zustand == 2 ) {
    $erste_karte->configure(-image => $test );
    $zweite_karte->configure(-image => $test );
    $zustand = 0;
    # print ("0\n");

    #sind alle karten aufgedeckt dann...

}elsif ( $zustand == 3 ){

    #ist eine karte aufgedeckt dann...

}elsif ( $zustand == 1 ){
    $schalter{$arg1}->configure(-image => $bildvari{$arg1} );
    $zweites_symbol = $kartenwert{$arg1};
    $zweite_karte = $schalter{$arg1};
    $zweites_argument = $arg1;

    #ist die ausgewähle karte schon umgedret dann...

    if ( $erstes_argument eq $zweites_argument) {
        $zustand = 1;
        #print ("1\n");

        #ist die zweit umgerete karten richtig dann...

    } elsif( $zweites_symbol eq $erstes_symbol ) {
        $paare_zaehlen = $paare_zaehlen + 1;

        #prüfe ob das Siel zu endeist...

        if ( $paare_zaehlen >= 8 ){
            $info->configure(-text => "Super! Alle \nPaare gefunden." );
            $zustand = 3;
        } else {
            $versuche_zaehlen = $versuche_zaehlen + 1;
            $info->configure(-text => "Versuch Nr. $versuche_zaehlen" );
            $erste_karte->configure(-state => 'disabled');
            $zweite_karte->configure(-state => 'disabled');
            $zustand = 0;
        }

        #...sind sie falsch dann..

    } elsif( $zweites_symbol ne $erstes_symbol ) {
        $versuche_zaehlen = $versuche_zaehlen + 1;
        $info->configure(-text => "Versuch Nr. $versuche_zaehlen" );
        $zustand = 2;
    }

    #ist keine karte aufgedeckt dann...

    }elsif( $zustand == 0 ) {
        $schalter{$arg1}->configure(-image => $bildvari{$arg1});
        $erstes_symbol = $kartenwert{$arg1};
        $erste_karte = $schalter{$arg1};
        $erstes_argument = $arg1;
        $zustand = 1;
    }
}

########## hir werden die arten gemischt ##############
sub karten_mischen {

    foreach $zuweisung (1...16) {
        $zaehler{"$zuweisung"} = 0
    }
    @kartenliste = ("$a","$a","$b","$b","$c","$c","$d","$d","$e","$e","$f","$f","$g","$g","$h","$h");
    foreach $karte (@kartenliste) {
        # eine do-schleife die, die Zahlen 1-16 in zufalliger reinvolge ausgibt. jede ein mal
        do {
            $zufall = int( rand(16)) +1;
            $zaehler{"$zufall"} = $zaehler{"$zufall"} + 1;
        } until ( $zaehler{"$zufall"} == 1);

        $kartenwert{"$zufall"} = "$karte"; # weist der karte einen Platz zu
        # print ($kartenwert{3});
    }
};

Perl/Tk Widgets