JLI Spieleprogrammierung Foren-Übersicht JLI Spieleprogrammierung

 
 FAQFAQ   SuchenSuchen   MitgliederlisteMitgliederliste   BenutzergruppenBenutzergruppen 
 medals.php?sid=40d3640f576d4a8c2ec275adc0a18369Medaillen   RegistrierenRegistrieren   ProfilProfil   Einloggen, um private Nachrichten zu lesenEinloggen, um private Nachrichten zu lesen   LoginLogin 

C# Graphic
Gehe zu Seite Zurück  1, 2
 
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Entwicklung
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen  
Autor Nachricht
City Hunter
Super JLI'ler


Alter: 38
Anmeldedatum: 18.04.2004
Beiträge: 330
Wohnort: Berlin
Medaillen: Keine

BeitragVerfasst am: 05.04.2012, 22:31    Titel: Antworten mit Zitat

Wünsche euch ein Schönes Osterfest.

Hab da mal wieder eine frage Embarassed .

hab ein kleines Pong spiel gemacht ohne XNA nur normales C#. Habe da ein Problem wenn der Ball die Obere Ecke des Schläger erreicht fliegt der Ball mit der unteren ecke des Balls einfach durch.

An was könnte das liegen?

CPP:
// ist er wieder links, prüfen wir, ob der Schläger in
            // der Nähe ist
            if ((position.X == spielfeldMinX) && ((schlaeger.Top <= position.Y) && (schlaeger.Bottom >= position.Y)))
            {
                if (ballPosition.richtungX == false)
                {
                    // einen Punkt dazu un die Punkte ausgeben
                    zeichnePunkte(Convert.ToString(spielpunkte.VeraenderePunkte(punkteMehr)));
                }
                // die Richtung ändern
                ballPosition.richtungX = true;
                // und den Winkel
                ballPosition.winkel = zufall.Next(winkelzufall);
            }


Sitze daran schon eine Weile. Vielleicht kann mir da ja einer helfen.

Hatt es was damit auf sich das der Ball voll auf den Schläger aufsetzen muss das er zurück fliegt? Oder wie muss ich da rangehen?

Bedanke mich jetzt schon mal.


Zuletzt bearbeitet von City Hunter am 07.04.2012, 11:02, insgesamt einmal bearbeitet
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden AIM-Name
The Lord of Programming
Living Legend


Alter: 36
Anmeldedatum: 14.03.2003
Beiträge: 3122

Medaillen: Keine

BeitragVerfasst am: 07.04.2012, 00:37    Titel: Antworten mit Zitat

Kannst du bitte in Zukunft die [ cpp ]-Tags hier statt [ code ] verwenden? Das sieht viel schöner zu lesen aus Wink

Zu deiner Frage:
Dein Ball ist wohl nicht nur ein Pixel groß. Du fragst aber nur den (wahrscheinlich) Mittelpunkt des Balls ab. Du musst natürlich prüfen, ob die Entfernung zwischen Schlägerkante/ecke und Mittelpunkt des Balls kleiner als der Radius des Balls ist.
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console


Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet...
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
City Hunter
Super JLI'ler


Alter: 38
Anmeldedatum: 18.04.2004
Beiträge: 330
Wohnort: Berlin
Medaillen: Keine

BeitragVerfasst am: 07.04.2012, 11:04    Titel: Antworten mit Zitat

Der Ball ist nen Panel und Rechteckig. Poste mal den ganzen Code

WEiß nicht ob da irgend wie ein kleinen Unterschied gibs ob rund oder Rechteck der Ball?

CPP:
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace Pong
{
    public partial class Form1 : Form
    {
        // die Felder
        // eine Struktur für die Richtung des Balls
        struct spielball
        {
            // wenn die Richtung true ist, geht es nach oben
            // bzw. nach rechts
            // sonst nach unten bzw. nach links
            public bool richtungX;
            public bool richtungY;
            // für die Veränderung des Bewegungswinkels
            public int winkel;
        }

        // für die Zeichenfläche
        Graphics zeichenflaeche;
        // für das Spielfeld
        Rectangle spielfeldGroesse;
        int spielfeldMaxX, spielfeldMaxY, spielfeldMinX, spielfeldMinY;
        int spielfeldLinienbreite;
        // für den SChläger
        int schlaegerGroesse;
        // für den Ball
        spielball ballPosition;
        // zum Zeichnen
        SolidBrush pinsel;
        // für die Schrift
        Font schrift;
        // angehalten oder laufen
        bool spielPause;
        // Verbleine Zeit aufnehmen
        int aktuelleSpielzeit;
        // Score
        Score spielpunkte;
        // für die Punkte
        int punkteMehr, punkteWeniger;
        // für die Veränderung des Winkels
        int winkelzufall; 
       
       

        void setzeSpielfeld()
        {
            spielfeldGroesse = spielfeld.ClientRectangle;
            // die minimalen und die Maximalen Ränder festlegen
            // dabei werden die Linien berücksichtigt
            spielfeldMaxX = spielfeldGroesse.Right - spielfeldLinienbreite;
            // den linken Rand verschieben wir ein Pixel nach
            // rechts
            spielfeldMinX = spielfeldGroesse.Left + spielfeldLinienbreite + 1;
            spielfeldMaxY = spielfeldGroesse.Bottom - spielfeldLinienbreite;
            spielfeldMinY = spielfeldGroesse.Top + spielfeldLinienbreite;
        }

        void zeichneSpielfeld()
        {
            // die weißen Begrenzungen
            pinsel.Color = Color.White;
            // ein Rechteck oben
            zeichenflaeche.FillRectangle(pinsel, 0, 0, spielfeldMaxX, spielfeldLinienbreite);
            // ein Rechteck rechts
            zeichenflaeche.FillRectangle(pinsel, spielfeldMaxX, 0, spielfeldLinienbreite, spielfeldMaxY + spielfeldLinienbreite);
            // und noch eins unten
            zeichenflaeche.FillRectangle(pinsel, 0, spielfeldMaxY, spielfeldMaxX, spielfeldLinienbreite);
            // damit es nicht langweilig wird, noch eine graue
            // Linie in die Mitte
            pinsel.Color = Color.Gray;
            zeichenflaeche.FillRectangle(pinsel, spielfeldMaxX / 2, spielfeldMinY, spielfeldLinienbreite, spielfeldMaxY - spielfeldLinienbreite);
        }

        void zeichneZeit(string restzeit)
        {
            // zuerst die alte Anzeige "überschreiben"
            pinsel.Color = spielfeld.BackColor;
            zeichenflaeche.FillRectangle(pinsel, spielfeldMaxX - 50, spielfeldMinY + 20, 30, 20);
            // in Weißer Schrift
            pinsel.Color = Color.White;
            // die Auszeichnungen für die Schrift werden beim
            // Erstellen des Spielfeldes gesetzt
            zeichenflaeche.DrawString(restzeit, schrift, pinsel, new Point(spielfeldMaxX - 50, spielfeldMinY + 20));
        }

        // erzeugt einen Dialog zum Neustart und liefert das
        // Ergebnis zurück
        bool neuesSpiel()
        {
            bool ergebnis = false;
            if (MessageBox.Show("Neues Spiel starten?", "Neues Spiel", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
            {
                // die Spielzeit neu setzen
                aktuelleSpielzeit = 120;
                // alles neu zeichnen
                zeichneSpielfeld();
                neuerBall();
                zeichneZeit(Convert.ToString(aktuelleSpielzeit));
                // die Punkte zurücksetzen und anzeigen
                spielpunkte.LoeschenPunkte();
                zeichnePunkte("0");
                // den Menüeintrag für die Einstellungen deaktivieren
                PausetoolStripMenuItem.Enabled = true;
                // Die Menüeinträge für die Einstellungen deaktivieren
                schwierigkeitsgradToolStripMenuItem.Enabled = false;
                einstellungenToolStripMenuItem.Enabled = false;
                ergebnis = true;
            }
            else
            {
                ergebnis = false;
            }
            return ergebnis;
        }

        // setzt die Position des Balls
        void zeichneBall(Point position)
        {
            // für die Zufallszahl
            Random zufall = new Random();
            ball.Location = position;
            // wenn der Ball rechts anstößt,ändern wir die
            // Richtung
            if ((position.X + 10) >= spielfeldMaxX)
            {
                ballPosition.richtungX = false;
            }
            // stößt er unten bzw. oben an, ebenfalls
            if ((position.Y + 10) >= spielfeldMaxY)
            {
                ballPosition.richtungY = true;
            }
            else
            {
                if(position.Y <= spielfeldMinY)
                {
                    ballPosition.richtungY = false;
                }
            }
            // ist er wieder links, prüfen wir, ob der Schläger in
            // der Nähe ist
            if ((position.X == spielfeldMinX) && ((schlaeger.Top <= position.Y) && (schlaeger.Bottom >= position.Y)))
            {
                if (ballPosition.richtungX == false)
                {
                    // einen Punkt dazu un die Punkte ausgeben
                    zeichnePunkte(Convert.ToString(spielpunkte.VeraenderePunkte(punkteMehr)));
                }
                // die Richtung ändern
                ballPosition.richtungX = true;
                // und den Winkel
                ballPosition.winkel = zufall.Next(winkelzufall);
            }

            // ist der Ball hinter dem Schläger?
            if (position.X < spielfeldMinX)
            {
                // 5 Punkte abziehen und die Punkte ausgeben
                zeichnePunkte(Convert.ToString(spielpunkte.VeraenderePunkte(-5)));
                // eine kurze Pause einlegen
                System.Threading.Thread.Sleep(1000);
                // und alles einer Zeile eingeben
                zeichneBall(new Point(spielfeldMinX, position.Y));
                ballPosition.richtungX = true;
            }
        }

        // setzt die Y-Position des Schlägers
        void zeichneSchlaeger(int Y)
        {
            // befindet sich der Schläger im Spielfeld?
            if (((Y + schlaegerGroesse) < spielfeldMaxY) && (Y > spielfeldMinY))
            {
                schlaeger.Top = Y;
            }           
        }

        // setzt die Einstellungen für einen neuen Ball und einen
        // neuen Schläger
        void neuerBall()
        {
            // die Größe des Balles setzen
            ball.Width = 10;
            ball.Height = 10;
            // die Größe des Schlägers setzen
            schlaeger.Width = spielfeldLinienbreite;
            schlaeger.Height = schlaegerGroesse;
            // beide Panels werden weiß
            ball.BackColor = Color.White;
            schlaeger.BackColor = Color.White;
            // den Schläger positionieren
            // links an den Rand
            schlaeger.Left = 2;
            // ungefähr in die Mitte
            zeichneSchlaeger((spielfeldMaxY / 2) - (schlaegerGroesse / 2));
            // der Ball kommt vor den Schläger ungefähr in die
            // Mitte
            zeichneBall(new Point(spielfeldMinX, spielfeldMaxY / 2));
        }

        void zeichnePunkte(string punkte)
        {
            // zuerst die alte Anzeige "überschreiben"
            pinsel.Color = spielfeld.BackColor;
            zeichenflaeche.FillRectangle(pinsel, spielfeldMaxX - 50, spielfeldMinY + 40, 30, 20);
            // in weißer Schrift
            pinsel.Color = Color.White;
            // die Einstelungen für die Schrift werden beim
            // Erstellen des Spielfeldes gesetzt
            zeichenflaeche.DrawString(punkte, schrift, pinsel, new Point(spielfeldMaxX - 50, spielfeldMinY + 40));
        }

        // setzt die Einstellungen für den Schwierigkeitsgrad
        void setzeEinstellungen(int schlaeger, int mehr, int weniger, int winkel)
        {
            schlaegerGroesse = schlaeger;
            punkteMehr = mehr;
            punkteWeniger = weniger;
            winkelzufall = winkel;
        }

        public Form1()
        {
            InitializeComponent();
            // die Breite der Linien
            spielfeldLinienbreite = 10;
            // die Größe des Schlägers
            schlaegerGroesse = 50;
            // erst einmal geht der Ball nach rechts und oben mit
            // dem Winkel 0
            ballPosition.richtungX = true;
            ballPosition.richtungY = true;
            ballPosition.winkel = 0;
            // den Pinsel erzeugen
            pinsel = new SolidBrush(Color.Black);
            // die Zeichenfläche beschaffen
            zeichenflaeche = spielfeld.CreateGraphics();
            // das Spielfeld bekommt einen schwarzen Hintergrund
            spielfeld.BackColor = Color.Black;
            // die Grenzen für das Spielfeld setzen
            setzeSpielfeld();
            // einen "neuen" Ball erstellen
            neuerBall();
            // erst einmal ist das Spiel angehalten
            spielPause = true;
            // alle drei Timer sind zunächst angehalten
            timerBall.Enabled = false;
            timerSpiel.Enabled = false;
            timerSekunde.Enabled = false;
            //die Schrift ist Arial 12 Punkt fett
            schrift = new Font("Arial", 12, FontStyle.Bold);
            // der Menüeintrag Pause ist zunächst deaktiviert
            PausetoolStripMenuItem.Enabled = false;
            //für die Bestenliste
            spielpunkte = new Score();
            // die Standardwerte setzen
            punkteMehr = 1;
            punkteWeniger = -5;
            winkelzufall = 5;
        }

        private void spielfeld_Paint(object sender, PaintEventArgs e)
        {
            // das Spielfeld zeichnen
            zeichneSpielfeld();
            // die Zeit ausgeben
            //zeichneZeit(Convert.ToString(aktuelleSpielzeit));
        }

        private void beendenToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Close();
        }

        private void schlaeger_MouseMove(object sender, MouseEventArgs e)
        {
            if (spielPause == true)
            {
                return;
            }
            if (e.Button == MouseButtons.Left)
            {
                zeichneSchlaeger(e.Y + schlaeger.Top);
            }
        }

        private void timerBall_Tick(object sender, EventArgs e)
        {
            int neuX = 0, neuY = 0;
            // abhängig von der Bewegungsrichtung die
            // Koordianaten neu setzen
            if (ballPosition.richtungX == true)
            {
                neuX = ball.Left + 10;
            }
            else
            {
                neuX = ball.Left - 10;
            }
            // abhängig von der Bewegungsrichtung die
            // Koordinaten neu setzen
            if (ballPosition.richtungY == true)
            {
                neuY = ball.Top - ballPosition.winkel;
            }
            else
            {
                neuY = ball.Top + ballPosition.winkel;
            }
            // den Ball neu zeichnen
            zeichneBall(new Point(neuX, neuY));
        }

        private void timerSekunde_Tick(object sender, EventArgs e)
        {
            //eine Sekunde abziehen
            aktuelleSpielzeit = aktuelleSpielzeit - 1;
            // die Restzeit ausgeben
            zeichneZeit(Convert.ToString(aktuelleSpielzeit));
        }

        private void PausetoolStripMenuItem_Click(object sender, EventArgs e)
        {
            // erst einmal prüfen wir den Status
            // läuft das Spiel?
            if (spielPause == false)
            {
                // alle Timer anhalten
                timerBall.Enabled = false;
                timerSekunde.Enabled = false;
                timerSpiel.Enabled = false;
                // die Markierung im Menü einschalten
                PausetoolStripMenuItem.Checked = true;
                // den Text in der Titelleiste ändern
                this.Text = "Pong - Das Spiel ist angehalten!";
                spielPause = true;
            }
            else
            {
                // das Intervall für die verbleibende Spielzeit
                // setzen
                timerSpiel.Interval = aktuelleSpielzeit * 1000;
                // alle Timer wieder an
                timerBall.Enabled = true;
                timerSekunde.Enabled = true;
                timerSpiel.Enabled = true;
                // die Markierung im Menü abschalten
                PausetoolStripMenuItem.Checked = false;
                // den Text in der Titelleiste ändern
                this.Text = "Pong";
                spielPause = false;
            }
        }

        private void timerSpiel_Tick(object sender, EventArgs e)
        {
            // das Spiel anhalten
            PausetoolStripMenuItem_Click(sender, e);
            // eine Meldung anzeigen
            MessageBox.Show("Die Zeit ist um.", "Spielende", MessageBoxButtons.OK, MessageBoxIcon.Information);
            // Abfrage, ob ein neues Spiel gestartet werden soll
            if (neuesSpiel() == true)
            {
                // das Spiel "fortsetzen"
                PausetoolStripMenuItem_Click(sender, e);
            }
            else
            {
                // sonst beenden
                beendenToolStripMenuItem_Click(sender, e);
            }
            // nachsehen, ob ein neuer Eintrag in der Bestenliste
            // erfolgen kann

            if (spielpunkte.NeuerEintrag() == true)
            {
                // Ball und Schläger "verstecken"
                ball.Hide();
                schlaeger.Hide();
                // die Liste ausgeben
                spielpunkte.ListeAusgaben(zeichenflaeche, spielfeldGroesse);
                // 5 Sekunden warten
                System.Threading.Thread.Sleep(5000);
                // die Zeichenfläche löschen
                zeichenflaeche.Clear(spielfeld.BackColor);
                // Ball und Schläger wieder anzeigen
                ball.Show();
                schlaeger.Show();
            }
        }

        private void neuesSpieltoolStripMenuItem_Click(object sender, EventArgs e)
        {
            // "läuft" ein Spiel?
            // dann erst einmal pausieren
            if (spielPause == false)
            {
                PausetoolStripMenuItem_Click(sender, e);
                // den Dialog anzeigen
                neuesSpiel();
                // und weiter spielen
                PausetoolStripMenuItem_Click(sender, e);
            }
            // wenn kein Spiel läuft, starten wir ein neues,
            // wenn im Dialog auf Ja geklickt wurde
            else
            {
                if (neuesSpiel() == true)
                {
                    PausetoolStripMenuItem_Click(sender, e);
                }
            }
        }

        private void BestenlistetoolStripMenuItem_Click(object sender, EventArgs e)
        {
            // zur Unterscheidung zwischen einem laufenden und
            // einem nicht gestarteeten Spiel
            bool weiter = false;
            // " läuft" ein Spiel? dann erst einmal pausieren
            if (spielPause == false)
            {
                PausetoolStripMenuItem_Click(sender, e);
                weiter = true;
            }
            // Ball und Schläger "verstecken"
            ball.Hide();
            schlaeger.Hide();
            // die Liste ausgeben
            spielpunkte.ListeAusgaben(zeichenflaeche, spielfeldGroesse);
            // 5 Sekunden warten
            System.Threading.Thread.Sleep(5000);
            // die Zeichenflaeche loeschen
            zeichenflaeche.Clear(spielfeld.BackColor);
            // Ball und Schläger wieder anzeigen
            ball.Show();
            schlaeger.Show();
            // das Spiel wieder fortsetzen, wenn wir es
            // ausgehalten haben
            if (weiter == true)
            {
                PausetoolStripMenuItem_Click(sender, e);
            }
        }

        private void sehr_einfachToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // das Intervall für den Ball setzen
            timerBall.Interval = 200;
            // die Einstellungen setzen
            setzeEinstellungen(100, 1, -20, 2);
            // und die Markierungen
            sehr_einfachToolStripMenuItem.Checked = true;
            einfachToolStripMenuItem.Checked = false;
            mittelToolStripMenuItem.Checked = false;
            SchwertoolStripMenuItem.Checked = false;
            sehrSchwerToolStripMenuItem.Checked = false;
        }

        private void einfachToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // das Intervall für den Ball setzen
            timerBall.Interval = 100;
            // die Einstellungen setzen
            setzeEinstellungen(50, 1, -5, 5);
            // und die Markierungen
            sehr_einfachToolStripMenuItem.Checked = false;
            einfachToolStripMenuItem.Checked = true;
            mittelToolStripMenuItem.Checked = false;
            SchwertoolStripMenuItem.Checked = false;
            sehrSchwerToolStripMenuItem.Checked = false;

        }

        private void mittelToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // das Intervall für den Ball setzen
            timerBall.Interval = 50;
            // die Einstellungen setzen
            setzeEinstellungen(50, 3, -5, 15);
            // und die Markierungen
            sehr_einfachToolStripMenuItem.Checked = false;
            einfachToolStripMenuItem.Checked = false;
            mittelToolStripMenuItem.Checked = true;
            SchwertoolStripMenuItem.Checked = false;
            sehrSchwerToolStripMenuItem.Checked = false;
        }

        private void SchwertoolStripMenuItem_Click(object sender, EventArgs e)
        {
            // das Intervall für den Ball setzen
            timerBall.Interval = 25;
            // die Einstellungen setzen
            setzeEinstellungen(50, 10, -5, 25);
            // und die Markierungen
            sehr_einfachToolStripMenuItem.Checked = false;
            einfachToolStripMenuItem.Checked = false;
            mittelToolStripMenuItem.Checked = false;
            SchwertoolStripMenuItem.Checked = true;
            sehrSchwerToolStripMenuItem.Checked = false;
        }

        private void sehrSchwerToolStripMenuItem_Click(object sender, EventArgs e)
        {
            // das Intervall für den Ball setzen
            timerBall.Interval = 10;
            // die Einstellungen setzen
            setzeEinstellungen(20, 0, -5, 40);
            // und die Markierungen
            sehr_einfachToolStripMenuItem.Checked = false;
            einfachToolStripMenuItem.Checked = false;
            mittelToolStripMenuItem.Checked = false;
            SchwertoolStripMenuItem.Checked = false;
            sehrSchwerToolStripMenuItem.Checked = true;
        }

        private void spielfeldToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Point Groesse = new Point(0, 0);

            EinstellungenDialog neueGroesse = new EinstellungenDialog(this.Width);
            // wenn der Dialog über die "OK"-Schaltfläche
            // beendet wird
            if (neueGroesse.ShowDialog() == DialogResult.OK)
            {
                // die neue Größe holen
                Groesse = neueGroesse.LiefereGroesse();
                // den Dialog wieder schließen
                neueGroesse.Close();
                // das Formular ändern
                this.Width = Groesse.X;
                this.Height = Groesse.Y;
                // neu ausrichten
                this.Left = (Screen.PrimaryScreen.Bounds.Width - this.Width) / 2;
                this.Top = (Screen.PrimaryScreen.Bounds.Height - this.Height) / 2;
                // die Zeichenfläche neu beschaffe
                zeichenflaeche = spielfeld.CreateGraphics();
                // das Spielfeld neu setzen
                setzeSpielfeld();
                // Spielfeld löschen
                zeichenflaeche.Clear(spielfeld.BackColor);
                // und einen neuen Ball ud einen neuen
                // Schläger zeichnen
                neuerBall();
            }
        }
    }
}
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden AIM-Name
The Lord of Programming
Living Legend


Alter: 36
Anmeldedatum: 14.03.2003
Beiträge: 3122

Medaillen: Keine

BeitragVerfasst am: 09.04.2012, 12:01    Titel: Antworten mit Zitat

Ich hab die Problemsituation nicht ganz verstanden.

Aber bei der geposteten Stelle hast du stehen: position.X == spielfeldMinX.
Wenn der Ball nicht immer nur um eine Einheit in X-Richtung verschoben wird, ist es natürlich Zufall, ob der Ball genau das Spielfeld-Minimum trifft und reflektiert wird.

PS: Es hilft einem selbst und anderen enorm, wenn Variablen und Funktionen treffende Namen haben. Es lohnt sich da wirklich, ein bisschen Zeit zu investieren, um einen gescheiten Namen zu finden oder ggf. auch mal abzuändern, wenn er nicht mehr passt. Das ist mir bei ein paar Dingen hier aufgefallen.
Beispiel: Zeichnet "zeichneBall()" wirklich den Ball oder setzt es eigentlich die Position?
Ist bei "ballPosition.richtungX" wirklich die X-Richtung aktiv bzw. true oder ist das eher eine Variable, die beschreibt, ob der Ball nun nach rechts geht oder nicht?
Überleg dir das mal Smile
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console


Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet...
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
City Hunter
Super JLI'ler


Alter: 38
Anmeldedatum: 18.04.2004
Beiträge: 330
Wohnort: Berlin
Medaillen: Keine

BeitragVerfasst am: 09.04.2012, 13:41    Titel: Antworten mit Zitat

Ja da spricht die erfahrung bei dir ^^. Ich muss mir das erst mal beibringen. Wink
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden AIM-Name
City Hunter
Super JLI'ler


Alter: 38
Anmeldedatum: 18.04.2004
Beiträge: 330
Wohnort: Berlin
Medaillen: Keine

BeitragVerfasst am: 15.04.2012, 09:57    Titel: Antworten mit Zitat

Sagt mal, kennt ihr eine INternet seite wo vorgeschlagen wird was man so Programmieren kann? das die sachen auch sitzenbleiben. Habe in moment keine Ideen was ich selber so schreiben könnte.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden AIM-Name
AFE-GmdG
JLI MVP
JLI MVP


Alter: 44
Anmeldedatum: 19.07.2002
Beiträge: 1374
Wohnort: Irgendwo im Universum...
Medaillen: Keine

BeitragVerfasst am: 15.04.2012, 10:58    Titel: Antworten mit Zitat

<Scherz>
http://dev.brain.iq
</Scherz>
_________________
CPP:
float o=0.075,h=1.5,T,r,O,l,I;int _,L=80,s=3200;main(){for(;s%L||
(h-=o,T= -2),s;4 -(r=O*O)<(l=I*I)|++ _==L&&write(1,(--s%L?_<(L)?--_
%6:6:7)+\"World! \\n\",1)&&(O=I=l=_=r=0,T+=o /2))O=I*2*O+h,I=l+T-r;}
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen
City Hunter
Super JLI'ler


Alter: 38
Anmeldedatum: 18.04.2004
Beiträge: 330
Wohnort: Berlin
Medaillen: Keine

BeitragVerfasst am: 15.04.2012, 11:03    Titel: Antworten mit Zitat

Sehr witzig AFE Wink. Also kennt keiner eine seite.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden AIM-Name
Jonathan_Klein
Living Legend


Alter: 36
Anmeldedatum: 17.02.2003
Beiträge: 3431
Wohnort: Siegerland
Medaillen: Keine

BeitragVerfasst am: 22.04.2012, 10:25    Titel: Antworten mit Zitat

Wenn du absolut keine Ideen hast, programmier doch einfach eins von folgenden, tollen Spielen nach (in zeitgemäßer Grafik Very Happy)

. Commander Keen 4
- Skunny Cart
- Earth Siege 2
- Tomb Raider 2

Wie kann man nur keine Ideen haben? Ich hab regelmäßig viel viel mehr, als ich jemals umsetzen könnte...
_________________
https://jonathank.de/games/
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen
The Lord of Programming
Living Legend


Alter: 36
Anmeldedatum: 14.03.2003
Beiträge: 3122

Medaillen: Keine

BeitragVerfasst am: 22.04.2012, 12:14    Titel: Antworten mit Zitat

Gib du ihm doch ein paar deiner Ideen, Jonathan Wink
Ich glaub, die Spiele mal eben nach zu programmieren, is ein bisschen hoch gegriffen.

City Hunter, ich glaube, es ist ziemlich egal, wozu das Enderzeugnis gut ist. Hauptsache ist, du machst einfach viel, wenn du Muster im Hirn manifestieren willst Wink
_________________
www.visualgamesentertainment.net
Current projects: RDTDC(1), JLI-Vor-Projekt, Tetris(-Tutorial), JLI-Format
(1) Realtime Developer Testing and Debugging Console


Anschlag, Anleitung zum Atombombenbau, Sprengkörper...
Hilf Schäuble! Damit er auch was findet...
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
City Hunter
Super JLI'ler


Alter: 38
Anmeldedatum: 18.04.2004
Beiträge: 330
Wohnort: Berlin
Medaillen: Keine

BeitragVerfasst am: 18.05.2012, 15:57    Titel: Antworten mit Zitat

Ja in moment bin ich Ideen los wegen Arbeit. ARbeite ja so schön auf den Flughafen der erst nächstes Jahr eröffnet wird *kotz* Don't
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden AIM-Name
AFE-GmdG
JLI MVP
JLI MVP


Alter: 44
Anmeldedatum: 19.07.2002
Beiträge: 1374
Wohnort: Irgendwo im Universum...
Medaillen: Keine

BeitragVerfasst am: 20.05.2012, 11:02    Titel: Antworten mit Zitat

Du warst das also, der den Feuerlöscher versteckt hat...
_________________
CPP:
float o=0.075,h=1.5,T,r,O,l,I;int _,L=80,s=3200;main(){for(;s%L||
(h-=o,T= -2),s;4 -(r=O*O)<(l=I*I)|++ _==L&&write(1,(--s%L?_<(L)?--_
%6:6:7)+\"World! \\n\",1)&&(O=I=l=_=r=0,T+=o /2))O=I*2*O+h,I=l+T-r;}
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen
Beiträge der letzten Zeit anzeigen:   
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Entwicklung Alle Zeiten sind GMT
Gehe zu Seite Zurück  1, 2
Seite 2 von 2

 
Gehe zu:  
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.


Powered by phpBB © 2001, 2005 phpBB Group
Deutsche Übersetzung von phpBB.de

Impressum