C++ Builder - Transparente Bilder, Grenzen definieren

Hi!

Wir haben in der Schule ein Programierprojekt.
Unser Projekt:
Ein Rollenpiel im "Zelda" Style.

Wir haben allerdings einige Probleme die uns die wirklisch beschießene Borlandhilfe nicht beantworten kann.
(Wie verwenden Borland c++ Builer 5)

1. Wie können wir Grafiken mit transparenten Hintergrund einfügen. .gif (was transparenten Hintergrund unterstützt) ünterstützt Borland nicht. Welche Formate gehen noch?

2. Da wir ja ein Rollenspiel machen, laufen wir ja mit einem Image rum. Jetzt bräcuhetn wir nur ein Weg, wie wir "verbotene" Bereiche definieren können, in die unsere Figur nicht hinein laufen kann.
Da die "Top" und "Left" eigenschaften ja nur einen Punkt definieren, ist es über diesen Weg sher schwer. Wenn jemand aber auch so eine Lösung weiß, her damit *gg*

Schon mal danke für die Hilfe.

Headhunter

Hi !

Da habt ihr aber ein recht schweres Projekt aufgebrummt bekommen

Ich weiß nicht wie im BCB die Grafikausgabe realisiert ist, von daher kann ich dir nicht sagen wie du dort .gifs laden kannst. Frag mal im BCB Forum nach

Such im FAQ mal nach Tileengine
Im Prinzip würde ich es so machen

//ein einzelnes tile (Feld)
struct STile
{
     //position und größe in pixeln, ich nehme für m_s? gerne relative Werte
     int m_px, m_py, m_sx, m_sy;

     //das ist die Textur mit der das Feld gezeichnet wird
     //der Datentyp TEXTURE muss natürlich irgendwo deklariert sein
     TEXTURE m_texture;

     //kann man hier drüberlaufen ?
     bool m_walkable;
};

//das ist das eigentliche level, ein 2dimensionales array
STile** level;

Das ist natürlich nur ein Ansatz, aber ich hoffe du kommst damit klar ? Wenn nicht, frag einfach nochmal

Sovok

benutzt ihr den alten oder den neuen zelda stil?
neu: zelda is zentriert und die welt um ihn bewegt sich
alt: jeder raum is so gross wie der bildschirm mit ausgängen am rand
der raum is zentriert und zelda bewegt sich durch den raum

einfacher zu programmiern is auf jeden fall die alte methode
bei der alten könntet ihr z.b. ein rechteck für den rand, die position der ein- und ausgänge und hinternisse im aktuellen raum definieren.
das ganze über bounding boxes, sprich rechtecke mit derren x und y positionen und grössen ihr die werte des spielers vergleicht, dazu reicht heads vorschlag

int m_p(osition)x, m_p(osition)y, m_s(ize)x, m_s(ize)y;

gruss sov

[ Dieser Beitrag wurde am 24.01.2003 um 18:40 Uhr von Sovok editiert. ]

Thargor

Hi!

Danke erstmal für eure Antworten.

Ich habs zwar noch nicht so ganz kapiert, da wir erst seit Schuljahrbeginn programmieren (und unser erstes Projekt ein Roulette war relativ einfach).

Wir wollen das mann überall auf dem Bildschirm rumlaufen kann.

Ich werd mal sehen ob ich es kapiere und umsetzen kann.

Und ein weiteres Problem:

Unsere KI funktioniert fast perfekt. Sie verfolgt denn Spieler und greift auch an. Nur bekommen wir es nicht hin, das der Gegner nicht in den Spileer hineinläuft.
Alle von uns entwickelten Kollisionsabfragen waren nicht einwandfrei.

[ Dieser Beitrag wurde am 27.01.2003 um 14:38 Uhr von Thargor editiert. ]

DasPinsch

Original erstellt von Thargor:
[QB]
Unsere KI funktioniert fast perfekt. Sie verfolgt denn Spieler und greift auch an. Nur bekommen wir es nicht hin, das der Gegner nicht in den Spileer hineinläuft.
Alle von uns entwickelten Kollisionsabfragen waren nicht einwandfrei.
QB]

Sorry das ich das sage, aber deine Beiträge hören sich irgendwie trollig an. (Ignorier dies einfach, wenn es nicht stimmt)

Damit Die Gegner nicht in den Spieler hineinlaufen, würde ich empfehlen, auszurechnen, wie groß der Abstand zwischen Spieler und Gegner ist. Nur Wenn dieser groß genug ist, darf sich der Gegner weiterbewegen.

Thargor

Hi!

Haben wir gemacht. Das funktioniert j aauch. Aber wenn der Spiler diesen Abstand unterschreitet, läuft der Gegner weiter. Wir ham schon versucht ne Variable wenn er nict weiterlaufen darf aucg 1 zu setzen und damit die lauftasten zu sperren, aber das hat nicht so funktioniert, wer dich aber nochmal probieren.

Was verstehst du unter "Trollig" ??

TGGC

Gabs nicht im FAQ schonmal was dazu?

DasPinsch

Original erstellt von Thargor:
**
Was verstehst du unter "Trollig" ??**

hmmm... es gab mal ne seite, wo beschrieben wurde was en troll ist

sonst such mal beiträge vom gerner, dann weisste was das heisst

Achso, zu deiner frage: ich weiss nicht, ob das zu kompliziert wird, aber ihr könntet ja den Richtungsvector des Gegners berchen, diesen dann normalisieren, und dann, sollte der Abstand vom Monter zum Spieler zu gering werden, denn minimumabstand mit dem Bewegungsvector multiplizieren. Die dann entstandenen Positionen addierst du dann zu den Spieler positionen, und schon habt ihr die neuen Positionen des Gegners .

[ Dieser Beitrag wurde am 28.01.2003 um 17:18 Uhr von DasPinsch editiert. ]

Thargor

Ich glaube ihr versteht das alle sein bissel falsch.

Wir AArbeiten auf der Standart c++ Builder Fläche. Vergleichbar mit Visual c++

Wir haben keinen Vollbildschirm, sondern eine Fläche die sonst eigentlich für Benutzeroberflächen gedacht sind.

Headhunter

Also einen 2D Leveleditor

miller_m

meinst du vielleich ein fenster in das du reinzeichnest ????

Thargor

Wir können nichts kein Zeichen.

Alles was dagestellt werden soll, mus in ein Image gepackt werden. Dieses Image wird dann bewegt.

Unter http://mitglied.lycos.de/schlenzi2002/bild.jpg könnt ihr sehen wie es aussieht.

Die Figuren werden noch geändert. Ist nur ein Test. *g*

Unt für Interesierte gibts auf http://dwtf-forum.dyndns.tv/einloftje/ ddass Zip Archiv mit dem Quelltext.

[ Dieser Beitrag wurde am 31.01.2003 um 13:29 Uhr von Thargor editiert. ]

Headhunter

Also möchtest du Animationen erstellen

miller_m

link zum saugen geht nicht

sehr aussage kräftiges bild.

willst du dein spieler bewegen ? möchtest du einen hintergrund erstellen ?
oder was möchtest du den machen, das weis glaub ich hier keiner so richtig.

Thargor

Bei mir geh der Link, komisch.

Der Hintergrund(die Karte) ist ein .jpg. Die Gegenstände und alles andere Ebenfalls.
Diese .jpg werden in Images geladen und die Images dann bewegt. (über Image1->Left=Image1->Left+5 u.ä)

Probleme: Wie vehindern wir, das man z.b. in einen Gegner oder Baum oder so reinlaufen kann(also hinter desem Image verschwindet) aber dieses Problem steht kurz vor der Lösung.

Für die Tranzparenz haben wir auch einen neuen Ansatz.

hier mal der Quellcode von "KI" und steuerung. Ich denke mal es wird keiner so richtig verstehen da Komentare fehlen und die Variablen komsiche nMAne haben) (astl = abstand Left, astt= Abstand Top)

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
int x,y,a,b; // Koords fürs laufen
int energie=100; // Gegner
int c,d,e,f,astt,astl; // Koordinaten, Abstand
int lp,lm,tp,tm; // Zustandvariablen
int bleiben; // stehenbleiben oder nicht
int energie1=100;   // Ich
int bild, bildki; // Varriable für das Bild
int rant; // Treffen oder nicht treffen, das ist hier die Frage
int gibtsgegner=0;  // Nur wenn =0 kann gelaufen werden.
int laufen[4];
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormKeyPress(TObject *Sender, char &Key)
{
// STEUERUNG

if(gibtsgegner==0) // Noch Gegner da, also kann gesteurert werden
{
switch(Key){  // Hier werden Tastendrücke abgefangen und das Image bewegt
            case 'w': if(laufen[0]==0)
                      {
                      Image1->Top = Image1->Top - 5;
                      ProgressBar2->Top=ProgressBar2->Top-5; //Die Energieanzeige muss mitbewegt werden
                      Image1->Picture = Image3->Picture; // Das Bild für NACHOBEN LAUFEN wird geladen
                      bild=1; // Hier wird gemerkt, welches Bild geladen ist
                      }
            break;
            case 'a': if(laufen[2]==0)
                      {
                      Image1->Left = Image1->Left - 5;
                      ProgressBar2->Left=ProgressBar2->Left-5;
                      Image1->Picture = Image4->Picture;
                      bild=3;
                      }
            break;
            case 's': if(laufen[1]==0)
                       {
                      Image1->Top = Image1->Top + 5;
                      ProgressBar2->Top=ProgressBar2->Top+5;
                      Image1->Picture = Image2->Picture;
                      bild=2;
                      }
            break;
            case 'd': if(laufen[3]==0)
                      {
                      Image1->Left = Image1->Left + 5;
                      ProgressBar2->Left=ProgressBar2->Left+5;
                      Image1->Picture = Image5->Picture;
                      bild=4;
                      }
            break;
           /* case 'z': {
                      Image1->Left = Image1->Left + 5;
                      Image1->Top = Image1->Top - 5;
                      }
            break;
            case 't': {
                      Image1->Left = Image1->Left - 5;
                      Image1->Top = Image1->Top - 5;
                      }
            break;
            case 'g': {
                      Image1->Left = Image1->Left - 5;
                      Image1->Top = Image1->Top + 5;
                      }
            break;
            case 'h': {
                      Image1->Left = Image1->Left + 5;
                      Image1->Top = Image1->Top + 5;
                      }
            break;*/
}

x=Image1->Left;  //Die Position wird eingelesen (vom Spieler)
y=Image1->Top;

a=Image6->Left;  //Position des Gegners
b=Image6->Top;

if(x-a<=150 || y-b<=150)//Wenn der Abstand klein genug ist, wird der Timer
{                       //und damit die "KI" aktiviert.
Timer1->Enabled=1;
}

if(x-a>=150 || y-b>=150)//Wenn der Abstand wieder zu groß ist, bleibt der Gegner stehen
{
Timer1->Enabled=0;
}

if(x || y == a || b) //Wenn der Gegner genau vor dem Spieler steht,
{
   if(x==a || y==b)
   {
   if(gibtsgegner==0)
   {
   switch(Key){

   case 'q': switch (bild){  //kann gekämpft werden,

             case 1: if(bildki==2 && astt==-50) // aber nur wenn sich beide anschauen
                     {  // so kann nicht gekämpft werden, wnen sie Rücken an Rücken stehen, wie es anfangs möglich war.
                     Image6->Top=Image6->Top-20;
                     ProgressBar1->Top=ProgressBar1->Top-20;//Bei Treffer zuckt der Gegner zurück
                     energie=energie-10 ;   //bekommt 10 Energie abgezogen
                     ProgressBar1->Position=ProgressBar1->Position-10;//was man auch an seiner Energieleiste sieht
                     }
             break;
             case 2: if(bildki==1 && astt==50)
                     {
                     Image6->Top=Image6->Top+20;
                     ProgressBar1->Top=ProgressBar1->Top+20;
                     energie=energie-10 ;
                     ProgressBar1->Position=ProgressBar1->Position-10;
                     }
             break;
             case 3: if(bildki==4 && astl==-35)
                     {
                     Image6->Left=Image6->Left-20;
                     ProgressBar1->Left=ProgressBar1->Left-20;
                     energie=energie-10 ;
                     ProgressBar1->Position=ProgressBar1->Position-10;
                     }
             break;
             case 4: if(bildki==3 && astl==35)
                     {
                     Image6->Left=Image6->Left+20;
                     ProgressBar1->Left=ProgressBar1->Left+20;
                     energie=energie-10 ;
                     ProgressBar1->Position=ProgressBar1->Position-10;
                     }
             break;
             }

             Label14->Caption=energie;// Energie wird angezeigt.
             if(energie<=0) //Falls der Gegner keine Energie mehr hat
               {
               Image6->Visible=0 ; //wird er unsichtbar
               ProgressBar1->Visible=0;
               gibtsgegner=1;   //und durch diese EInstellung kann nicht mehr gesteuert werden
               Timer1->Enabled=0;
               }
             }
}
}
}
}

}
//---------------------------------------------------------------------------

void __fastcall TForm1::FormCreate(TObject *Sender)
{
randomize();
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Timer1Timer(TObject *Sender)
{
// "KI"
if(gibtsgegner==0)  // Auch sie läuft nur wenn Gegner da sind
{
c=Image1->Left;//Die Position des Gegners und des Spielers werden eingelesen
d=Image1->Top;
e=Image6->Left;
f=Image6->Top;
bleiben=0; // Variable zum sthen beliebn des Gegners, wenn er direkt vor dem Spieler steht

laufen[0]=0; //Versuchtes verhindern des "in den Gegner"laufens. Funktioniert nicht richtig
laufen[1]=0;
laufen[2]=0;
laufen[3]=0;

astl=e-c; // Die Abstände werden berechnet
astt=f-d;

Label1->Caption=astl;  //und angezeigt
Label2->Caption=astt;

lm=0;
lp=0;
tm=0;
tp=0;

if(astl<=0)  // Es wird untersucht ob die Abstände im + oder im - Bereich liegen
{            // um gebau festzustellen wie er laufen muss
lm=1;
}
if(astl>=0)
{
lp=1;
}

if(astt<=0)
{
tm=1;
}
if(astt>=0)
{
tp=1;
}

Label3->Caption=lp; // die Werte werden angezeigt
Label7->Caption=lm;
Label8->Caption=tp;
Label9->Caption=tm;

if(astt==-50 || astt==50 || astl==35 || astl==-35)//Trifft zu wenn Gegner genau vor Spieler steht.
{
Image6->Left=Image6->Left; //Gegner tritt auf der Stelle
Image6->Top=Image6->Top;
bleiben=1; // so wird der restliche Teil nicht mehr ausgeführt.

rant=random(2); // Triift er oder trifft er nicht?

if(rant==1) // Falls sein Schlag getroffen hat.
{
if(bild==1 && bildki==2) // Er kann aber nur trweffen wenn er den Spieler anschaut
{
energie1=energie1-5;    // Energie wird abgezogen
ProgressBar2->Position=ProgressBar2->Position-5;
//ProgressBar2->Top=ProgressBar2->Top+20;
//Image1->Top=Image1->Top+20;
laufen[0]=1; //Nur ein versuch, klappt nicht
}
if(bild==2 && bildki==1)
{
energie1=energie1-5;
ProgressBar2->Position=ProgressBar2->Position-5;
//ProgressBar2->Top=ProgressBar2->Top-20;
//Image1->Top=Image1->Top-20;
laufen[1]=1;
}
if(bild==3 && bildki==4)
{
energie1=energie1-5;
ProgressBar2->Position=ProgressBar2->Position-5;
//ProgressBar2->Top=ProgressBar2->Left+20;
//Image1->Top=Image1->Left+20;
laufen[2]=1;
}
if(bild==4 && bildki==3)
{
energie1=energie1-5;
ProgressBar2->Position=ProgressBar2->Position-5;
//ProgressBar2->Top=ProgressBar2->Left-20;
//Image1->Top=Image1->Left-20;
laufen[3]=1;
}

}

Label17->Caption=energie1;  // Energie wird angezeigt

if(energie1<=0)      //falls der Spieler keine Energie mehr hat
{
Label15->Visible=1;  //wird "Kaputt" sichtbar
Image1->Visible=0;   // der Spieler unsichtbar
gibtsgegner=1;       // und nichts geht mehr
Timer1->Enabled=0;
ProgressBar2->Visible=0;
}
}

if(bleiben==0)// das macht er nur, wenn der Gegner nicht direkt vor dem Spieler steht
{
if(lp==1 && tp==1 && lm==0 && tm==0)//Die Positionsabfragen
{
Image6->Left=Image6->Left-5;  //Diagonal auf den Spieler zubewegen.
Image6->Top=Image6->Top-5;
ProgressBar1->Left=ProgressBar1->Left-5;
ProgressBar1->Top=ProgressBar1->Top-5;
}

if(lp==1 && tm==1 && lm==0 && tp==0)
{
Image6->Left=Image6->Left-5;
Image6->Top=Image6->Top+5;
ProgressBar1->Left=ProgressBar1->Left-5;
ProgressBar1->Top=ProgressBar1->Top+5;
}

if(lm==1 && tp==1 && lp==0 && tm==0)
{
Image6->Left=Image6->Left+5;
Image6->Top=Image6->Top-5;
ProgressBar1->Left=ProgressBar1->Left+5;
ProgressBar1->Top=ProgressBar1->Top-5;
}

if(lm==1 && tm==1 && lp==0 && tp==0)
{
Image6->Left=Image6->Left+5;
Image6->Top=Image6->Top+5;
ProgressBar1->Left=ProgressBar1->Left+5;
ProgressBar1->Top=ProgressBar1->Top+5;
}

if(lp==1 && lm==1 && tp==0 && tm==1)  // Wenn der Gegner getrade auf den Spieler zulaufen kann.
{
Image6->Top=Image6->Top+5;       //Nur gerade Bewegungen auf ihm zu.
Image6->Picture=Image2->Picture;
ProgressBar1->Top=ProgressBar1->Top+5;
bildki=2;
}

if(lp==1 && lm==1 && tp==1 && tm==0)
{
Image6->Top=Image6->Top-5;
Image6->Picture=Image3->Picture;
ProgressBar1->Top=ProgressBar1->Top-5;
bildki=1;
}

if(lp==0 && lm==1 && tp==1 && tp==1)
{
Image6->Left=Image6->Left+5;
Image6->Picture=Image5->Picture;
ProgressBar1->Left=ProgressBar1->Left+5;
bildki=4;
}

if(lp==1 && lm==0 && tp==1 && tp==1)
{
Image6->Left=Image6->Left-5;
Image6->Picture=Image4->Picture;
ProgressBar1->Left=ProgressBar1->Left-5;
bildki=3;
}
}

}
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
Timer1->Enabled=0;
}
//---------------------------------------------------------------------------

Jetzt mit Komentare. Ich weiß, ich kann nciht richtig kommentieren. Ich hoffe es irgendjemand kapiert es *g*

[ Dieser Beitrag wurde am 01.02.2003 um 09:37 Uhr von Thargor editiert. ]

[ Dieser Beitrag wurde am 01.02.2003 um 09:57 Uhr von Thargor editiert. ]

Thargor

Transparent ist geschaft zund Sperrbeereiche auch.

WebFritzi

Wir können nichts rein Zeichen

Aber natürlich. Was glaubst du denn, was ihr da die ganze Zeit macht?! Ihr bekommt nur nix davon mit, da der BCB euch die Zeichenarbeit abnimmt. Macht euch as Flimmern denn garnichts aus?