du könntest dein Programm in einer Dauerschleife laufen lassen und zB immer 100ms schlafen legen, dann die aktuelle Zeit ermitteln und entsprechend (Bruchteile von) Ressourcen aufaddieren

hört sich gut an. ich weis blos nicht was für befehle ich dafür brauch und wie die funktionieren. ich bin für jede hilfe dankbar.

lg
Paul

du könntest dein Programm in einer Dauerschleife laufen lassen und zB immer 100ms schlafen legen ...

Damit meinte er wohl das:

#include <windows.h>

int main()
{
    while(true)
    {
        /*
            1000 ms schlafen ...
        */
        Sleep(1000);

        /*
            ... dann geht es weiter.
        */
    }

    return 0;
}

Da muss aber noch eine Abbruchbedingung rein :xmas1:

gruß

//...
int holz = 0;

//...
if(eingabe == "holz") holz += 5;

//
void timerfunc()
{
    ++holz;
}

//...
cout << "Sie haben " << holz << "Holz übrig\n";

würde ich das lieber so machen:

#include <ctime>

double GetProgramTime()
{
    return clock() / (double)CLOCKS_PER_SEC;
}

double start_time = 0;
int holz = 0;

int GetHolz()
{
    return holz + (GetProgramTime() - start_time) * 5;
}

//...
void StartGame()
{
    start_time = GetProgramTime();
    //...
}

//...
if(eingabe == "holz") holz += 5;

//...
cout << "Sie haben " << GetHolz() << "Holz übrig\n";

was ich möchte ist:
ein programm in bei dem sich mehrere variablen auf einmal um verschiedene faktoren erhöhen. das soll die ganze zeit während des programms passieren. die faktoren um die erhöht wird, ändern sich immer mal wieder und man soll währen der ganzen zeit über noch unabhängige eingaben machen können. das programm müsste also gleichzeitig variablen erhöhen, diese ausgeben und eingaben verarbeiten können.
geht so was in c++ oder brauch ich da was anderes??

Erstmal: In C++ geht fast alles, wenn du das richtige Werkzeug hast.
Um effizient zu arbeiten, solltest du in deinem Fall einen extra Thread anlegen, der für die Variablenerhöhung zuständig ist.

Um effizient zu arbeiten, solltest du in deinem Fall einen extra Thread anlegen

Noch effizienter wäre, den Systemtimer zu verwenden.

class AgendaItem
{
   unsigned int CoolDown_;
   unsigned int Counter_;

public:
   AgendaItem( unsigned int Cool ) : CoolDown_( Cool ), Counter_( Cool )
   {
   }

   virtual ~AgendaItem()
   {
   }

   // Trigger ist pure virtual
   virtual void trigger() = 0;

   // wird regelmässig vom externen Timer aufgerufen
   void on_timer()
   {
      // Trigger auslösen?
      if( Counter_ == 0 )
      { 
         // Trigger auslösen und Counter zurücksetzen
         trigger();
         Counter_ = CoolDown_;
      }
      --Counter_;
   }
};

class AgendaItemGainWood : public AgendaItem
{
   Player& Player_;

public:
   AgendaItemGainWood( Player& Player ) : 
      AgendaItem( 500 ),
      Player_( Player )
   {
   }

   void trigger()
   {
      // Ressource aktualisieren
      Player.Wood += 5;
   }
};

Zum Spielstart musst du eine Agenda befüllen und diese durch einen externen Timer/Thread zyklisch aktualisieren. Jedes Agenda Item hat einen Cooldown, der bei jedem Timeraufruf um 1 reduziert wird. Ist der Cooldown 0 wird die trigger() Methode des Agenda Items aufgerufen und der Cooldown auf den Initialwert zurückgesetzt. Die Timerauflösung sollte man relativ hoch wählen (z.B. 10ms oder 50ms) und den Cooldown Wert entsprechend hoch setzen, damit kann man den Ablauf detailliert steuern.
Ausserdem kann man die Spielgeschwindigkeit variieren, indem man die Timerauflösung verändert, die Realtion der Häufigkeit der auftretenden Ereignisse wird ja nicht verändert.

In meinem Beispiel habe ich dem Ereignis "GainWood" einen Cooldown von 500 gegeben, das sollte bei einer Timerauflösung von 10ms also alle 5 Sekunden auftreten.

@all others
danke für eure hilfe, ich schau mal was ich draus machen kann

@Christian Ivicevic:
coole umschreibung das du mich zu dumm dafür hällst, muss ich mir merken.

Ich weiß ja nicht, was er über dich denkt, aber das sollte dir mitteilen, dass du erstmal mit einfacheren Sachen anfangen solltest, wenn du keine dieser Techniken verstehst. Du würdest ja auch nicht in der 2. Klasse Bruchrechnen unterrichten, obwohl die Schüler nicht unbedingt dumm sein müssen.

Außerdem sind Timer und Threads ein einfaches Konzept und sollten eigentlich recht früh gelernt werden und wenn du da schon aussetzt, dann ist dies wieder ein Zeichen, dass es sein kann, dass du nicht im Element bist.

Kurz gesagt: Dies ist ausgeschrieben, dass was wxSkip auch angesprochen hat.

Gruß

PS: Bei allem Respekt, entschuldige mich, wenn ich dir damit zu nahe getreten sein sollte!