Könnt ihr mir bei meinem Processing-Spiel helfen?

Hey, ich habe eine Frage zu einem Java-Code. Und zwar habe ich ein unfertiges Spiel gemacht, wo drei Kugeln herunterfallen und wieder oben erscheinen, falls diese ganz unten angekommen sind.

Im Programmieren bin ich noch ein Anfänger und ich habe nicht so viel Wissen dazu.

Mit den Pfeiltasten rechts und links kann man unten das Rechteck bewegen.

Die Kugeln erhalten immer eine neue Farbe, wenn sie oben neu erscheinen.

Meine zwei Fragen wären:

  1. Wie kann ich es so machen, dass, wenn eine Kugel wieder oben erscheint, nur diese vom fill-Befehl betroffen ist und somit nicht das Rechteck und alle anderen Kugeln eine neue Farbe erhalten, wenn eine Kugel oben neu erscheint (Priorität)?
  2. Wie kann ich die Bewegung vom Rechteck smoother machen? Weil wenn man zu schnell rechts und links drückt, dann laggt das und geht irgendwie in die entgegengesetze Richtung, die man drückt (optional).

Den Code habe ich in Processing geschrieben.

Ich bedanke mich schon einmal im Voraus für jede Antwort.

Hier der Code:

float x = 200; // Rechts-, Links-Wert für den Eimer
float x1 = 250; // Wo die 1. Kugel sich horizontal befindet
float y1 = 0; // Wo die 1. Kugel sich vertikal befindet
float x2 = 100; // Wo die 2. Kugel sich horizontal befindet
float y2 = 50; // Wo die 2. Kugel sich vertikal befindet
float x3 = 385; // Wo die 3. Kugel sich horizontal befindet
float y3 = 250; // Wo die 3. Kugel sich vertikal befindet

void setup() {
  size(500, 500);
}

void draw() {
  background(0, 255, 0);

  // Die fallenden Kugeln:

  // 1. Kugel
  ellipse(x1, y1, 50, 50);
  y1 = y1 + 2;

  if (y1 > 500) {
    fill(random(0, 255));
    y1 = 0;
    x1 = random(50, 450);
  }

  // 2. Kugel
  ellipse(x2, y2, 50, 50);
  y2 = y2 + 2;

  if (y2 > 500) {
    fill(random(0, 255));
    y2 = 0;
    x2 = random(50, 450);
  }

  // 3. Kugel
  ellipse(x3, y3, 50, 50);
  y3 = y3 + 2;

  if (y3 > 500) {
    fill(random(0, 255));
    y3 = 0;
    x3 = random(50, 450);
  }

  // Der Eimer:
  noStroke();
  rect(x, 400, 100, 50);

  if (keyPressed) {
    if (keyCode == LEFT && x >0) {
      x = x - 5;
    }

    if (keyCode == RIGHT && x <400) {
      x = x + 5;
    }
  }
}
Java, Code, Programmiersprache
ReactNative Code wird "verschluckt"?

Tach zusammen.
Ich arbeite derzeit an einer App mit ReactNative für Android. Ich nutze also Android Studio und die Emulatoren davon bzw. nur das Pixel 3 und Pixel 8 mit SDK 34.

Folgender Code soll ein zufälliges Wort aus dem Array auslesen. Wenn der Input korrekt ist, dieses Wort aus dem Array löschen und ein neues Wort wählen.

Manchmal (nicht immer) wird aber das selbe Wort nochmal gewählt. Das ist auch so, wenn ich mit einer if-Schleife verhindere, dass das selbe Wort doppelt dran kommen kann.

Ich habe an jeder erdenklichen Position timeouts und if schleifen verbaut (es sind nicht alle immer noch vorhanden) aber nichts ändert etwas. Liegt das am Emulator? Ich habe derzeit wegen Zeitproblemen keine Möglichkeit, das ganze an einem echten Gerät zu testen, darum die Frage.

const checkWord = () => {
        if (input === solution) {
            setIsVisible(false);
            setCurrentWord((prevWord) => Number(prevWord) + 1);

            // Entferne das Wortpaar aus WordsArray
            const updatedWordsArray = WordsArray.filter(pair => pair.wortpaar !== wortpaar);
            setWordsArray(updatedWordsArray); // Update the WordsArray state

            // Überprüfen, ob noch Wörter vorhanden sind
            if (updatedWordsArray.length === 0) {
                finish();
                setStopCours(true);
                setIsRunning(false);
            } else {
                setTimeout(() => {
                    getRandomWord(); // Hier getRandomWord aufrufen
                    setInput('');
                }, 250);
            }
        } else {
            toggleVisibility();
        }
};

const getRandomWord = () => {
    if (stopCours === false) {
        if (!isRunning) return;

        console.log('getRandomWord called');
        if (WordsArray && WordsArray.length > 0) {
            const pairs = WordsArray.reduce((acc, { value, wortpaar, typ }) => {
                if (!acc[wortpaar]) {
                    acc[wortpaar] = { original: null, learn: null, wortpaar: wortpaar };
                }
                if (typ === "originalText") {
                    acc[wortpaar].original = value;
                } else if (typ === "learnText") {
                    acc[wortpaar].learn = value;
                }
                return acc;
            }, {});

            const pairNumbers = Object.keys(pairs);
            const filteredPairNumbers = pairNumbers.filter(pairNumber => WordsArray.some(pair => pair.wortpaar === pairNumber));

            if (filteredPairNumbers.length === 0) {
                finish();
                setIsRunning(false);
                setStopCours(true);
                return;
            }

            // Zufälliges Paar auswählen
            const randomPairNumber = filteredPairNumbers[Math.floor(Math.random() * filteredPairNumbers.length)];
            const selectedPair = pairs[randomPairNumber];

            // Setze die Werte für das neue Wortpaar
            setSolution(selectedPair.learn);
            setWord(selectedPair.original);
            setWortpaar(selectedPair.wortpaar);
            setSeeSolution('Lösung anzeigen');
        }
    }
};
 
JavaScript, Array, Programmiersprache, React Native

Meistgelesene Beiträge zum Thema Programmiersprache