Galcon auf dem Pandora

[MaeKeaPott]

Also ich spiele ja zur Zeit fleißig GalCon auf meinem Windows-PC. Die Grafik von Galacon ist viel Interessanter. Obwohl mir der blitz ein wenig zu hell erscheint: Das müßten wenigstens die Schiffe schwarz erscheinen, da sieht man ja gar nichts mehr. Wenn umzuliegende Planeten jedoch noch Armen zur letzten Rettung beherbegen würde, wie soll man die da losschicken wo man nichts sieht? Der Effekt sieht allerdings 1a aus. Nur eben halt mehr kontrast zu den Raumschiffen und eventuell angrenzende Planeten noch mal in den Vordergrund legen.

Zu den Map-Design, wo es bis jetzt noch schwer fällt per Zufall die Chancengleichheit darzustellen: Leider weiß ich nicht wie man hier im Board Bilder postet und hab wieder vergessen wie man im Internet Bilder öffentlich parkt. Zum anderen müßte ich die Bilder aber auch stärker überarbeiten, da ich jetzt einfach mal Bilder von GalCon genommen hab - den auch dort gibt es leider probleme mit der fairnis. Dabei scheint mir eine Lösung recht einfach.
Wie werden eigentlich die Planeten-Positionen in einer XML Datei festgehalten: Fest auf einer Matrix oder relativ zueinander? Und wie wird durch Zufall die Position von Planeten festgelegt werden, ohne das sich Planeten irgendwann überlappen - bestimmt gib es da eine Funktion die prüft, das ein Mindestabstand eingehalten wird: Warum nicht diese Funktion gleich benutzen um die Planeten am Anfang fair zu verteilen.
Da ich jetzt wie gesagt hier keine Bilder hochladen kann (weil es auch gegen das Urheberrecht verstoßen könnte), mal ein anderes Bild: Man nehme drei 5 Euro-Cent für die 3 Basen der Spieler und gut wäre wenn man nun genügend 2 und 1 Cent-Stücke hätte um einfach mal Planeten-Maps zu Simulieren: Schmeißt man diese nun einfach auf einen Zettel der den Bildschirm darstellen mag, würde ja die Gefahr bestehen, das sich Planeten Positionen fürchertlich verteilen.
Wenn man anfängt die Centstücke gerecht zu verteilen könnte folgendes vorgehen hilfreich sein: Einen Bleistiftkreis in die Mitte des Blattes der einen Radius hat, der fast an die Blattkante stößt. Die Basen werden auf diesem Kreis in einem regelmässigen Abstand angeordnet: 2 würden sich Gegenüber liegen. Drei sind im Dreieck aufgeteilt. Vier im Quadrat und so weiter. So hat jeder die selbe Nachbarzahl und die selbe Entfehrnung zum Zentrum der Galaxis. Dann könnte man mit dem Bleistift von jeder Basis eine Linie in die Mitte des Blattes ziehen und wenn man den ersten Planeten setzt, so wird der Winkel von einer gedachten Linie der naheliegend Basis zu seiner Zentrum Linie genommen und weitere Planeten werden entsprechend mit den selben Winkel gesetzt. So bekommt eine Map recht einfach eine größtmögliche fairnis. Sieht allerdings bescheuert aus, und ob es dann auch noch spaß macht...?
Allerdings: Die Idee mit den Winkeln und der Entfehrnung ist doch schon nicht schlecht. Laßen wir also mal das Blatt - den Bildschirm beiseite. Und legen jede Station weitgenug voneinander entfehrnt auf den Boden. Jede ist an sich das Zentrum. Wir verteilen die Planeten wieder gerecht. Bekommt eine Basis einen großen Planeten als Nachbarn, bekommen die anderen auch einen entsprechenden Planeten als Nachbarn. Dazu würfelt man erst einmal die Entfehrnung aus und die Größe des Planetens. An der Größe des Planetens richtet sich dann in welchen Bereich die Produktionsstärke des Planeten gesetzt wird. Zum schluß wird noch eine neutrale Besatzungsstärke ausgewürfelt. Dann wird für jede Basis eine Richtung ausgewüfelt und der Planet entsprechend in dieser Richtung relativ um die Entfehrnung verschoben gesetzt. Man erhelt nun immerhin entwas verschieden wirkende Cluster die alle jedoch die selben start-Chancen aufweisen. Erst durch das zusammenschieben der Cluster wird nun der weitere Spielverlauf zum Vor- oder Nachteil des einen oder anderen Spielers.
Am besten schiebt man die Cluster zum Schluß so zusammen, das die Verknüpfungspunkte auch gewisse entfehrnungen zueinander einhalten.
Nach sieht das Bild dadurch Monoton aus, das zu jeder Basis gleichgroße Planeten entsprechend der Anzahl der Basen plaziert werden. Wenn man jedoch die Größe oder Entfehrnung eines Planeten variert, so kann man einen fairen ausgleich schafen, inden man nähere Planeten entsprechend stärker mit Schutztruppen ausstafiert bzw. weiter weg gelegene Planeten mit weniger Truppen - doch Achtung: für jede Basis sollte eine Maximal Radius gelten, in dem die Planeten verteilt werden, der die hälfte der Streck zu anderen Basis entspricht.
Na? Klingt das nach einer fairen Verteilung?
Vielleicht schaffe ich es am Wochenende mal ein BASIC Programm für Windows zu schreiben, das diese Verteilungsmuster darstellt, um dann zu beweisen, ob meine Gedanken nicht all zu verkehrt sind...

 

[otaco]

p&|a Hier ein erstmal ein Video von einer glorreich, eher ruhigen Partie:
http://91.67.169.12/~otaco/publish/...intergalactic_2008-10-24_02-01-37-40_xvid.avi (240 MB, 800x480)

p&|a Eins der YouTube Videos in nativer Auflösung
http://91.67.169.12/~otaco/publish/post/intergalactic/video/intergalactic_2008-09-07_xvid.avi (74MB, 800x480)

(sag mal einer ob die Links gehen)

Danke Mae für deine Gedanken. Es ist auf jeden Fall schwer keine Muster oder Regelmäßigkeiten in die Planetenanordnung zu bekommen wenn man es fair macht. Ich hab mir da erlich gesagt noch nicht so viel Gedanken gemacht, da ich wie gesagt ehr auf den Editor setze. Aber hey, wenn du was schönes hinbekommst lass es mich wissen.

Hier ein bisschen Code. Die Drei Methoden erzeugen die Planeten, verteilen Punkte und rücken die Planeten auseinander, so das sie einen minimalen Abstand zueinader haben. Das ist natürlich alles sehr provisorisch und ist nur zum Testen gedacht gewesen. Alle Parameter zum erstellen der Map stehen noch im Code, aber ich kompilier eh die ganze Zeit .

(Der Source ließt sich sicher besser wenn man ihn in einen Editor mit Syntaxhighlight kompiert)

<i>
</i>
///////////////////////////////////////////////////////////////////////////////


  /// create world

void
World::createRandomWorld()
{
  
  /// clear old world
  if (_planets.size())
  {
    for(unsigned int i=0; i != _planets.size(); ++i)
    {
      delete _planets[i]; 
    }
    _planets.clear();   
  }
  
  
  // number of players
  _numPlayers = (int)(4);
  
  /// create planets
  unsigned int numPlanets = (int)(gloost::frand()*25 + 15);
  
  float performanceBase      = 0.6;
  float performanceVariation = 1.1;
  
  gloost::TextLog::getInstance()->addLine();  
  gloost::TextLog::getInstance()->addLine("createRandomWorld(): Creating A new World...",
                                          gloost::vec3(1.0, 1.0, 1.0));
  gloost::TextLog::getInstance()->addLine("                    " + gloost::toString(numPlanets) + " Planets",
                                          gloost::vec3(1.0, 1.0, 1.0));

  
  for(unsigned int i=0; i != numPlanets-_numPlayers; ++i)
  {
	  gloost::Vector3 loc(gloost::crand()*_worldSize[0]*2.5,
	                      gloost::crand()*_worldSize[1]*1.5,
	                       0.0);
	  float           performance   = performanceBase + gloost::frand()/*gloost::frand()*/*performanceVariation;
	  unsigned int    owner  = 0;
    
    ig::Planet* planet = new ig::Planet(_planets.size(), loc, performance, 0.0f, owner);
    
    _planets.push_back(planet);
  }
  
  
  /// create players planets
  for(unsigned int i=1; i != _numPlayers; ++i)
  {
    gloost::Vector3 loc(gloost::frand()*_worldSize[0],
                        gloost::frand()*_worldSize[1],
                         0.0);
    float           performance = 2.2;
    float           points = 100.0 + i*10;
    
    ig::Planet* planet1 = new ig::Planet(_planets.size(), loc, performance, points, i);
    
    _planets.push_back(planet1);
  }
  
  
  resolvePlanetCollisions();
  setPlanetPoints();
}


///////////////////////////////////////////////////////////////////////////////


  /// set start points of the grey planets

void
World::setPlanetPoints()
{
  if (!_planets.size())
  {
    return;  
  }
  
  for(unsigned int i=0; i != _planets.size(); ++i)
  {
	  if (_planets[i]->getOwner() == 0)
	  {
	    _planets[i]->setPoints(   _planets[i]->getPerformance() * (20 +
	                              (gloost::frand()*gloost::frand()*260)));
	  }
  }
}


///////////////////////////////////////////////////////////////////////////////


  /// resolve collisions of the planets

bool
World::resolvePlanetCollisions()
{
  unsigned int borderToFrameTop = 20;
  unsigned int borderToFrame    = 20;
  unsigned int planetSpacing    = 100;
  
  
  bool         foundCollision = 1;
  unsigned int cycleCounter = 0;
  
  while (foundCollision)
  {
    ++cycleCounter;
    foundCollision = 0;
    
    for(unsigned int i=0; i != _planets.size(); ++i)
    {
      for(unsigned int j=0; j != _planets.size(); ++j)
      {
        
        if (i != j)
        {
          gloost::Vector3 dist   = _planets[i]->getLoc() - _planets[j]->getLoc();
          float           length = dist.length();
          
          // check distance between planets
          if ((length*2.0 - planetSpacing) < (_planets[i]->getSize() + _planets[j]->getSize()))
          {
            foundCollision = 1;
            dist.normalize();
            _planets[i]->addToLoc(dist.scalar(0.5));
            _planets[j]->addToLoc(dist.scalar(-0.5));
          }
          
          // handle frameborder contrains horizontal
          if (_planets[i]->getLoc()[0] < 0 + borderToFrame + _planets[i]->getSize()*0.5)
          {
            foundCollision = 1;
            _planets[i]->addToLoc(gloost::Vector3(1.0, 0.0, 0.0));
          }
          if (_planets[i]->getLoc()[0] > _worldSize[0] - borderToFrame - _planets[i]->getSize()*0.5)
          {
            foundCollision = 1;
            _planets[i]->addToLoc(gloost::Vector3(-1.0, 0.0, 0.0));
          }
          
          // handle frameborder contrains vertical
          if (_planets[i]->getLoc()[1] < 0 + borderToFrame + _planets[i]->getSize()*0.5)
          {
            foundCollision = 1;
            _planets[i]->addToLoc(gloost::Vector3(0.0, 1.0, 0.0));
          }
          
          if (_planets[i]->getLoc()[1] > _worldSize[1] - borderToFrameTop - _planets[i]->getSize()*0.5)
          {
            foundCollision = 1;
            _planets[i]->addToLoc(gloost::Vector3(0.0, -1.0, 0.0));
          }
        }
      }
    }
    

    
    if (cycleCounter > 1000)
    {
      
      gloost::TextLog::getInstance()->addLine("createRandomWorld(): Could't resolve world after 5000 iterations!",
                                              gloost::vec3(1.0, 0.2, 0.2));
      createRandomWorld();  
    } 
    
    
  }
  
  gloost::TextLog::getInstance()->addLine("resolvePlanetCollisions(): resolved in " + gloost::toString(cycleCounter) + " itterations",
                                          gloost::vec3(1.0, 1.0, 1.0));

  return foundCollision;
}

 

[otaco]

Hab gerade meinen Thread im englischen Forum aktualisiert. Es gibt es ein neues Video zu sehen und auch die making of - Gallerie hat nun ein Paar Bilder mehr.

Hier die Links:

YouTube Video 3:
http://www.youtube.com/watch?v=n1YGlpYvptg

YouTube Video in nativer Pandora Auflösung (137 MB):
http://gonzo.uni-weimar.de/~weiszig...intergalactic 2008-12-06 16-26-21-71_xvid.avi

Ein viel längers Video inklusive der Szenen aus dem YouTube Video (235 MB):
http://gonzo.uni-weimar.de/~weiszig...intergalactic 2008-12-06 16-19-45-53_xvid.avi

Ein Paar Concepts die auch was mit dem Spiel zu tun haben :
http://gonzo.uni-weimar.de/~weiszig/references/shooter/


Hier der Link zum englischen Forum:
http://www.gp32x.com/board/index.php?showtopic=43655&st=15&p=676500&#entry676500

 

[shodan]

hej otaco
coole Sache. video läd noch, aber die youtube variante sieht ja schonmal toll aus. vielen dank fürs update!
sind die concept-pictures aus zwischensequenzen oder wofür brauchst die fiesen alientintenfischle? oO
sehn n´ bisschen nach diesen flugsaugern[name vergessen] aus Matrix aus.

shodan

edit: video angeschaut - ich mag dein spiel otaco farben, formen, ablauf.
bin saumäßig gespannt wie sichs letztendlich spielen wird!

 

[Gurumeditation]

aus dem spiel kann man noch viel machen, aber freu mich auf diese umsetzung..hab bisher ja nur ne demo gespielt aufm pc und war davon schon begeistert.

 

[Xant]

ich freu mich schon drauf werden sicher geile und lange runden.
da wir beim thema lang sind so ne runde scheint bei 4 parteien, wie im einen video, recht lange gehen zu können da ballert jeder seine schiffe überall hin.
sieht echt stressig aus.^^

 

[MaeKeaPott]

Mir ist aufgefallen, das die Raumschiffe einfach über die Planeten fliegen, ohne dabei Tempo abzunehmen. Dabei müssen die doch einen Bogen fliegen - und daher langsamer werden. Das würde auch das tatkieren erschwären!

 

[fusion_power]

Hat beim zusehn irgend was meditatives.

Ich hätte im Moment höchstens ein paar kosmetische Anmerkungen. Jeder Planet auf einer Map könnte ne andere Oberflächenstruktur haben, dann siehts nicht so langweilig aus. Und der Hintergrund könnte sich bei jeder neue Map ändern, es gibt tolle Weltraum-Bilder mit exotischen nebeln und farbigen Gaswolken etc...

 

[rosemartine]

I watched it on you tube and this game is looking interesting.