Wann ist das Handy am Zug

  • Antworten:2
  • OffenNicht stickyBentwortet
  • Forum-Beiträge: 308

25.03.2020, 10:12:09 via Website

Hallo zusammen

Ich entwickle ein Spiel in welchem man gegen das Handy antritt. Der Spielzug vom Handybesitzer mache ich mittels eines Buttons.

obj_spiel = findViewById(R.id.btn_spiel);
    obj_spiel.setOnClickListener(new Button.OnClickListener() {
        @Override
        public void onClick(View view) {
            boolean b_was;
            for(int x=0; x < 7 ;x++){
                for(int y=0; y < 9;y++){
                    b_was = (boolean) img_spiel[x][y].getTag(R.id.loesch);
                    //anzeige löschen
                    if( b_was ){
                        img_spiel[x][y].setVisibility(View.INVISIBLE);
                    }
                }
            }
            n_anzahl = 0;
            //Computer ist am Zug
            compi_zug();
        }
    });

Im Klicklisener führe ich den Zug vom Spieler aus und mit der Methode "compi_zug" lasse ich das Handy spielen. Dies ist aber aus diversen Gründen nicht so gut. Der Spielzug vom Spieler wird erst visualisiert wenn der Klicklisener verlassen wird. Das ist einfach zu spät.

Aber wie kann ich Triggern, dass der Handyspieler fertig ist und nun das Handy an der Reihe ist? Wie machen das andere Spiele?

Gruss Renato

Der vollständigkeitshalber der ganze Code.

package ch.robbisoft.nimapp;

import androidx.appcompat.app.AlertDialog;
import androidx.appcompat.app.AppCompatActivity;

import android.content.DialogInterface;
import android.graphics.Bitmap;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;

import java.lang.reflect.Array;
import java.util.ArrayList;

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

private ImageView img_spiel[][];

private AlertDialog.Builder dlg_schale;
private Button obj_spiel;
private Button obj_neu;

private int n_schale;
private int n_anzahl;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    img_spiel = new ImageView[7][9];

    img_spiel[0][0] = findViewById(R.id.img_eins_eins);
    img_spiel[0][1] = findViewById(R.id.img_eins_zwei);
    img_spiel[0][2] = findViewById(R.id.img_eins_drei);
    img_spiel[0][3] = findViewById(R.id.img_eins_vier);
    img_spiel[0][4] = findViewById(R.id.img_eins_fuenf);
    img_spiel[0][5] = findViewById(R.id.img_eins_sechs);
    img_spiel[0][6] = findViewById(R.id.img_eins_sieben);
    img_spiel[0][7] = findViewById(R.id.img_eins_acht);
    img_spiel[0][8] = findViewById(R.id.img_eins_neun);
    img_spiel[1][0] = findViewById(R.id.img_zwei_eins);
    img_spiel[1][1] = findViewById(R.id.img_zwei_zwei);
    img_spiel[1][2] = findViewById(R.id.img_zwei_drei);
    img_spiel[1][3] = findViewById(R.id.img_zwei_vier);
    img_spiel[1][4] = findViewById(R.id.img_zwei_fuenf);
    img_spiel[1][5] = findViewById(R.id.img_zwei_sechs);
    img_spiel[1][6] = findViewById(R.id.img_zwei_sieben);
    img_spiel[1][7] = findViewById(R.id.img_zwei_acht);
    img_spiel[1][8] = findViewById(R.id.img_zwei_neuen);
    img_spiel[2][0] = findViewById(R.id.img_drei_eins);
    img_spiel[2][1] = findViewById(R.id.img_drei_zwei);
    img_spiel[2][2] = findViewById(R.id.img_drei_drei);
    img_spiel[2][3] = findViewById(R.id.img_drei_vier);
    img_spiel[2][4] = findViewById(R.id.img_drei_fuenf);
    img_spiel[2][5] = findViewById(R.id.img_drei_sechs);
    img_spiel[2][6] = findViewById(R.id.img_drei_sieben);
    img_spiel[2][7] = findViewById(R.id.img_drei_acht);
    img_spiel[2][8] = findViewById(R.id.img_drei_neuen);
    img_spiel[3][0] = findViewById(R.id.img_vier_eins);
    img_spiel[3][1] = findViewById(R.id.img_vier_zwei);
    img_spiel[3][2] = findViewById(R.id.img_vier_drei);
    img_spiel[3][3] = findViewById(R.id.img_vier_vier);
    img_spiel[3][4] = findViewById(R.id.img_vier_fuenf);
    img_spiel[3][5] = findViewById(R.id.img_vier_sechs);
    img_spiel[3][6] = findViewById(R.id.img_vier_sieben);
    img_spiel[3][7] = findViewById(R.id.img_vier_acht);
    img_spiel[3][8] = findViewById(R.id.img_vier_neun);
    img_spiel[4][0] = findViewById(R.id.img_fuenf_eins);
    img_spiel[4][1] = findViewById(R.id.img_fuenf_zwei);
    img_spiel[4][2] = findViewById(R.id.img_fuenf_drei);
    img_spiel[4][3] = findViewById(R.id.img_fuenf_vier);
    img_spiel[4][4] = findViewById(R.id.img_fuenf_fuenf);
    img_spiel[4][5] = findViewById(R.id.img_fuenf_sechs);
    img_spiel[4][6] = findViewById(R.id.img_fuenf_sieben);
    img_spiel[4][7] = findViewById(R.id.img_fuenf_acht);
    img_spiel[4][8] = findViewById(R.id.img_fuenf_neun);
    img_spiel[5][0] = findViewById(R.id.img_sechs_eins);
    img_spiel[5][1] = findViewById(R.id.img_sechs_zwei);
    img_spiel[5][2] = findViewById(R.id.img_sechs_drei);
    img_spiel[5][3] = findViewById(R.id.img_sechs_vier);
    img_spiel[5][4] = findViewById(R.id.img_sechs_fuenf);
    img_spiel[5][5] = findViewById(R.id.img_sechs_sechs);
    img_spiel[5][6] = findViewById(R.id.img_sechs_sieben);
    img_spiel[5][7] = findViewById(R.id.img_sechs_acht);
    img_spiel[5][8] = findViewById(R.id.img_sechs_neun);
    img_spiel[6][0] = findViewById(R.id.img_sieben_eins);
    img_spiel[6][1] = findViewById(R.id.img_sieben_zwei);
    img_spiel[6][2] = findViewById(R.id.img_sieben_drei);
    img_spiel[6][3] = findViewById(R.id.img_sieben_vier);
    img_spiel[6][4] = findViewById(R.id.img_sechs_fuenf);
    img_spiel[6][5] = findViewById(R.id.img_sieben_sechs);
    img_spiel[6][6] = findViewById(R.id.img_sieben_sieben);
    img_spiel[6][7] = findViewById(R.id.img_sieben_acht);
    img_spiel[6][8] = findViewById(R.id.img_sieben_neun);

    //Bilder nicht neu setzen
    init(false);

    DialogInterface.OnClickListener positivListener = new DialogInterface.OnClickListener() {
        @Override
        public void onClick(DialogInterface dialogInterface, int i) {
            dialogInterface.dismiss();
        }
    };

    dlg_schale = new AlertDialog.Builder(MainActivity.this);
    dlg_schale.setMessage(getResources().getString(R.string.txt_SchaleFehler));
    dlg_schale.setPositiveButton("OK", positivListener);

    obj_spiel = findViewById(R.id.btn_spiel);
    obj_spiel.setOnClickListener(new Button.OnClickListener() {
        @Override
        public void onClick(View view) {
            boolean b_was;
            for(int x=0; x < 7 ;x++){
                for(int y=0; y < 9;y++){
                    b_was = (boolean) img_spiel[x][y].getTag(R.id.loesch);
                    //anzeige löschen
                    if( b_was ){
                        img_spiel[x][y].setVisibility(View.INVISIBLE);
                    }
                }
            }
            n_anzahl = 0;
            //Computer ist am Zug
            compi_zug();
        }
    });

    obj_neu = findViewById(R.id.btn_neu);
    obj_neu.setOnClickListener(new Button.OnClickListener(){
        @Override
        public void onClick(View view) {
            //Bilder neu setzen
            init(true);
        }
    });
}

/**********************************************************************************************
 * Der Computer ist am Zug
 *
 * @author robbisoft  @since 24. März 2020
 * @param
 * @return
 * @exception
 * @throws
 **********************************************************************************************/
private void compi_zug() {
    int n_masse[] = new int[7];//Spiel zum Spielen
    int n_jetzt[] = new int[7];//Spiel um Spiel festzuhalten
    int n_pool, n_res, n_compischale;
    boolean b_zustand;

    //ermitteln wieviele noch vorhanden sind und Spielstand festhalten
    for(int x=0; x < 7 ;x++){
        n_pool = 0;
        for(int y=0; y < 9 ;y++){
            b_zustand = (boolean) img_spiel[x][y].getTag(R.id.loesch);
            if(!b_zustand){
                n_pool++;
            }
        }
        n_masse[x] = n_pool;
        n_jetzt[x] = n_pool;
    }
    //Spielzug ermitteln
    n_compischale = 6; //Ich beginne von unten vielleicht durch Zufall ersetzen
    do {
        //Zug vornehmen nur aus derselben Schale
        n_masse[n_compischale]--;
        //Wenn Schale leer ist Stand zurücksetzen und eine Schale nach oben gehen
        if( n_masse[n_compischale] < 0 ){
            n_masse[n_compischale] = n_jetzt[n_compischale];
            n_compischale--;
            n_masse[n_compischale]--;
        }
        //testen
        n_res = rechne(n_masse);
    }while (n_res != 0);
    //Differenz ermitteln und Zug vornehmen
}

@Override
public void onClick(View view) {
    ImageView objekt;
    Bitmap bild, test;
    Drawable test_bild;
    int n_test;
    boolean b_setzen = true;

    objekt = (ImageView) view;
    //Schale prüfen
    n_test = (int) objekt.getTag(R.id.schale);
    if( n_anzahl > 0 ){
        //prüfen ob es aus der selben Schale entnommen wurde
        if( n_schale != n_test ){
            dlg_schale.show();
            b_setzen = false;
        }
    }else{
        n_schale = n_test;
    }
    if( b_setzen ) {
        //Bild prüfen
        bild = ((BitmapDrawable) objekt.getDrawable()).getBitmap();
        test_bild = getResources().getDrawable(R.drawable.sweet_64_delete);
        test = ((BitmapDrawable) test_bild).getBitmap();
        if (bild.sameAs(test)) {
            objekt.setImageResource(R.drawable.sweet_64);
            objekt.setTag(R.id.loesch, false);
            n_anzahl--;
        } else {
            objekt.setImageResource(R.drawable.sweet_64_delete);
            objekt.setTag(R.id.loesch, true);
            n_anzahl++;
        }
    }
}

/**********************************************************************************************
 * Initialisiert das Spiel
 *
 * @author robbisoft  @since 24. März 2020
 * @param Sollen die Bilder neu gesetzt werden
 * @return
 * @exception
 * @throws
 **********************************************************************************************/
private void init(boolean b_bilder){
    n_schale = 0;
    n_anzahl = 0;

    for(int x=0; x < 7; x++){
        for(int y=0; y < 9; y++){
            if( b_bilder ){
                img_spiel[x][y].setImageResource(R.drawable.sweet_64);
                img_spiel[x][y].setVisibility(View.VISIBLE);
            }
            img_spiel[x][y].setTag(R.id.loesch, false);
            img_spiel[x][y].setTag(R.id.schale, x);
            img_spiel[x][y].setOnClickListener(this);
        }
    }
}

/**********************************************************************************************
 * Berechnet den Spielstand
 *
 * @author robbisoft  @since 24. März 2020
 * @param
 * @return
 * @exception
 * @throws
 **********************************************************************************************/
private int rechne(int n_stand[] ){
    int n_res;
    n_res = n_stand[0] ^ n_stand[1] ^ n_stand[2] ^ n_stand[3] ^ n_stand[4] ^ n_stand[5] ^ n_stand[6];
    return n_res;
}

}

Diskutiere mit!
Beste Antwort
  • Forum-Beiträge: 1.219

25.03.2020, 10:37:36 via Website

Hallo eine einfache Lösung könnte sein einen Button für den Computer zu erstellen.
Diesen kannst du auch unsichtbar machen, wenn du willst.
Wenn der User fertig ist also am Ende des Listner machst du entweder den Button sichtbar oder triggerst ihn.
So das der Butten des Computer entweder durch den User gestartet wird oder durch deinen Trigger.
Den du am Ende in deinem Listner „User Listner“ auslöst.
Beim Triggern muss er nicht sichtbar sein. Aber vorhanden. Auch der dazugehörige Listner.
Den willst du ja Triggern.
„View.preformClick();“
http://developer.android.com/reference/android/view/View.html#performClick()

oder du steuerst das Ganze mit Asynctasks

— geändert am 25.03.2020, 10:40:25

Hilfreich?
Diskutiere mit!
Empfohlene Artikel bei NextPit