[Daepilin]

Jo, ich brauch hilfe. ich suche eine möglichkeit ein bestimmtes programm automatisch bei schließen eines spieles auszuführen. udn auch beim start des spiels.

es geht da um ein programm zum regeln der taktraten bei ati karten, womit ich die leistung meiner hd4870 im idle extrem herunterfahre. leider vergesse ich manchmal sie wieder hochzusetzten... das alleine wäre ja kein problem( mit einer batch datei. das taktratentool läuft über die startparameter der verknüpfung( heißt ich hab 2 verknüpfungen, einmal hoger einmal niedriger takt). ).

Aber kann ich die startparameter da überhaupt übernehmen? Die weitere frage ist aber schwerer: Öfters vergess ich das programm für die niedrigen taktraten nach beendigung eines spieles wieder auszuführen udn die graka läuft auf voller power weiter( und greift nichmal auf hauseigene stromsparmöglichkeiten zurück). Gibts also eine möglichkeit abzufragen ob das eben gestartete spiel geschlossen wurde ?

könnte mir das auch in c++ selber proggen, wenn ihr mir dazu tipps gebt. der rest( wie ich ne verknüpfung inkl startparameter ausführe) wäre aber auch nicht schlecht^^ musste noch nie andere programme aus c++ heraus ausführen^^

zusammengefasst suche ich folgendes( als batchdatei( eher nicht, denke ich?) oder als möglichkeit für c++):

1. Programm ausführen( hohe taktraten)
2. spiel starten( also für jedes spiel ne eigene exe bzw in c++ würd ich mir nen auswahlmenü dazupacken)
3. nach beenden des spiels neue verknüpfung( niedrige taktrate) ausführen.

ps: das tool heißt übrigends: AMDGPUClockTool

[ojas]

1. Programm ausführen( hohe taktraten)
2. spiel starten( also für jedes spiel ne eigene exe bzw in c++ würd ich mir nen auswahlmenü dazupacken)
3. nach beenden des spiels neue verknüpfung( niedrige taktrate) ausführen.

1. Führe eine der statischen Process.Start-Methoden aus um die Taktrate zu erhöhen.
2. Führe eine der statischen Process.Start-Methoden aus um das Spiel zu starten.
3. Auf dem zurückgelieferten Process-Objekt des zweiten Aufrufs rufst du WaitForExit aus.
4. Führe eine der statischen Process.Start-Methoden aus um die Taktrate zu senken.

[Daepilin]

dankeschön,a ber noch 1 frage. wie übergebe ich beim starten des programms die startparameter( kann sein, dass das schon im beispeil ist, aber ich habs jetzt nich auf die schnelle gefunden. )

edit: ok, dürfte der letzte punkt( Starts a process resource by specifying the name of an application and a set of command-line arguments, and associates the resource with a new Process component. ) sein, oder?

und das ganze läuft in .net? brauch ich da bei codeblocks außer dem c++ compiler( mingw) nochwas zu? (hab noch nich mit .net gearbeitet. aber drüber steht, dass die funktionen aus der .net library sind)

[ojas]

edit: ok, dürfte der letzte punkt ... sein, oder?

Ich habe da jetzt nicht mehr reingeschaut, aber nach dem was du zitiert hast sieht es gut aus.

und das ganze läuft in .net?

Ja. Es gibt wohl auch eine WinAPI-Funktion, die ähnliches leistet. Ich erinnere mich dunkel an CreateProcess, musst du mal schauen ob du dazu bei MSDN etwas findest.

brauch ich da bei codeblocks außer dem c++ compiler( mingw) nochwas zu?

Das weiß ich nicht. Ich weiß aber, das Microsoft für die Verwendung des .NET-Frameworks einen eigenen C++-Dialekt erschaffen hat; der nennt sich C++/CLI. Ob MinGW diesen kennt weiß ich auch nicht, ich glaube aber eher nicht. Und ob Code:: Blocks eine alternative Methode zur Verwendung des .NET-Frameworks anbietet bezweifel ich ebenfalls.

Allerdings kannst du für .NET-Programme die kostenlose Visual Studio Express Edition verwenden.

[Daepilin]

danke für den letzten tipp. is das dann auch schon eingerichtet oder muss ich da auch noch viel anpassen? werds mir morgen aber auf alle fälle mal angucken. um 23uhr is mir nichmehr nach arbeit^^

[ojas]

... oder muss ich da auch noch viel anpassen?

Nö, das is dann auch schon eingerichtet.

[Daepilin]

ok, hab mal angefangen und schon nen problem( wer hätte es gedacht -_-)

beim compilieren bekomm ich immer folgenden fehler:

1>GamesAndMore.cpp(22): error C2228: Links von ".WaitForExit" muss sich eine Klasse/Struktur/Union befinden.

mein code sieht bisher so aus:

// GamesAndMore.cpp: Hauptprojektdatei.

#include "stdafx.h"


using namespace System;
using namespace System::Diagnostics;
using namespace System::ComponentModel;

void main()
{
    int iEingabe;
    std::cout<<"Zum starten 1 eingeben: ";
    std::cin >> iEingabe;

    ProcessStartInfo* Game = new ProcessStartInfo(S"IExplore.exe");

    Game->Arguments = S"www.northwindtraders.com";

    Process::Start(Game);

    Game.WaitForExit();

    std::cout<<"Programm Beendet";
    std::cin.get();
    std::cin.get();
}

ich find leider auch keine c++ beispiele zu waitforexit, wo ich mir das mal anschauen könnte -_- alles nur vb oder c#...

[Thoronador]

ok, hab mal angefangen und schon nen problem( wer hätte es gedacht -_-)

beim compilieren bekomm ich immer folgenden fehler:

1>GamesAndMore.cpp(22): error C2228: Links von ".WaitForExit" muss sich eine Klasse/Struktur/Union befinden.

Probiere es mal mit

Game->WaitForExit();

Dann sollte diese Fehlermeldung verschwinden.

ich find leider auch keine c++ beispiele zu waitforexit, wo ich mir das mal anschauen könnte -_- alles nur vb oder c#...

Und wieso ist das ein Problem? Die API-Funktionen müssten doch die gleichen sein, egal welche Sprache verwendet wird.

[Daepilin]

weil da auch oft der prozessaufruf anders gehandhabt wird wie bei dem c++ beispiel in der msdn.

edit: hmpf... wenn ichs so mache kommt:

1>GamesAndMore.cpp(22): error C2039: 'WaitForExit': Ist kein Element von 'System::Diagnostics::ProcessStartInfo'
1>          c:\program files (x86)\reference assemblies\microsoft\framework\.netframework\v4.0\system.dll: Siehe Deklaration von 'System::Diagnostics::ProcessStartInfo'

[ojas]

Darf ich dich vielleicht an Punkt 3 meiner obigen Ausführungen erinnern. Dort steht

Auf dem zurückgelieferten Process-Objekt des zweiten Aufrufs rufst du WaitForExit aus.

Hier noch mal der gleiche Satz, aber diese Mal habe ich herausgehoben, worauf du achten musst.

Auf dem zurückgelieferten Process-Objekt des zweiten Aufrufs rufst du WaitForExit aus.

Das zurückgelieferte Process-Objekt fängst du aber überhaupt nicht ein, sondern du ignorierst es indem du einfach schreibst

Process::Start(Game);

Richtig wäre allerdings

Process iexplore_process = Process::Start(Game);

Dann kannst du nämlich später sagen

iexplore_process.WaitForExit()

Du musst in der Dokumentation genau hinschauen und zu den Methodenaufrufen, die du verwendest, folgendes herausfinden.

1. Welche Typen haben die Parameter von Methodenaufruf?
2. Wie beinflussen die Parameter den Ablauf der Methode?
3. Welchen Typ hat der Rückgabewert der Methode?
4. Was bedeutet der Rückgabewert?

[Daepilin]

dankeschön. dachte Game würde als Prozessinstanz gelten. nja, werds ausprobieren, gehe aber davon aus, dass es jetzt funzt^^ kam mit der msdn nie gut zurecht...

edit: ok, funzt. danke^^ Musste allerdings

Process* GameStart = Process::Start(Game);
GameStart->WaitForExit();

verwenden, sonst hats fehler gegeben. ( ja, auch nachdem ich auf

gameStart.WaitForExit();

umgestellt hatte.)

[ojas]

... kam mit der msdn nie gut zurecht...

Ich früher auch nicht. Ist Übungssache; und wichtig. Zum Beispiel habe ich das was du vorhast noch nie gemacht und auch meine Erfahrungen mit .NET gehen nicht über eine Lernkartei für mein Mobiltelefon hinaus. Dokumentation lesen zu können ist einer der Schlüsselkompetenzen von Softwareentwicklern (neben Quelltext lesen können)

Musste allerdings

Process* GameStart = Process::Start(Game);
GameStart->WaitForExit();

verwenden, ...

Ich muss einfach in der Dokumentation genau hinschauen und zu den Methodenaufrufen, die ich vorschlage, folgendes herausfinden.

1. ...
2. ...
3. Welchen Typ hat der Rückgabewert der Methode?
4. ...

OK, Scherz beiseite, der Fehler kam daher, das ich bei C# geschaut habe und du C++ verwendest.

[Daepilin]

hab mich nochmal drangesetzt, allerdings wieder ein kleines problem.
dazu hatte ich im c-plusplus forum gefragt, aber nru sehr oberflächliche antworten bekommen,d aher hier nochmal( der thread-> http://www.c-plusplus.de/forum/p2046387#2046387).

Mein Eingangspost da:

Hallo Leute. Ich hab vor einiger zeit( n halbes jahr her xD) angefangen mir ne art gamelauncher zu schreiben. darin will ich die Dateipfade und Spielnamen aus ner .cfg auslesen, und dann starte.

das auslesen klappt:

std::ifstream ifs;
    ifs.open("C:\\Users\\Martin\\Documents\\Visual Studio 2010\\Projects\\GamesAndMore\\GamesAndMore\\Config\\Config.cfg");
    
    std::string GameName[256];
    int PathNumber = 1;

    while ( ! ifs.eof() ) {
        std::string aLine = "";
        std::getline(ifs, aLine);
        aLine = aLine + "\n";

        const char* Line = aLine.c_str();
        std::string Name = ""; 

        for (int i=0; i<= aLine.size(); i++)
        {
            if(Line[i] == 42)
            {
                i++;
                for( int PathCursor = i; PathCursor <= aLine.size(); PathCursor++)
                {
                    GameName[PathNumber] = GameName[PathNumber] + Line[PathCursor];
                }

                Name = Name + "\n";
                i = aLine.size() + 1;
            }
            else{
                Name = Name + Line[i];
            }
        }

        std::cout<<Name;
        PathNumber++;        

     
    }
     
    ifs.close();

das funzt alles wie es soll ( ich weiß, dass ich keine fehlerbetrachtung drin habe).

Die Werte im Array stimmen auch.

Das ist der teil der nicht funzt:

int iEingabe;
    std::cout<<"Zum starten die Nummer des Spiels  eingeben: ";
    std::cin >> iEingabe;
    String* GameStartName ="";

    MarshalString(GameStartName, GameName[iEingabe]);

    ProcessStartInfo* GPUClockHigh = new ProcessStartInfo(S"C:\\Program Files (x86)\\AMD GPU Clock Tool\\AMDGPUClockTool.exe");

        GPUClockHigh->Arguments = S"-eng=750 -mem=900";

        Process* GPUClockHigh_Process = Process::Start(GPUClockHigh);

        GPUClockHigh_Process->WaitForExit();

        std::cout<<"Taktrate erfolgreich gesteigert, Spiel wird gestartet. Viel Spass.";



    ProcessStartInfo* Game = new ProcessStartInfo(GameStartName);

    Process* GameStart = Process::Start(Game);

    GameStart->WaitForExit();



    ProcessStartInfo* GPUClockLow = new ProcessStartInfo(S"C:\\Program Files (x86)\\AMD GPU Clock Tool\\AMDGPUClockTool.exe");

        GPUClockLow->Arguments = S"-eng=200 -mem=200";

        Process* GPUClockLow_Process = Process::Start(GPUClockLow);

        GPUClockLow_Process->WaitForExit();

        std::cout<<"\nTaktrate erfolgreich gesenkt. Programm wird beendet.";

es wird einfach der string GameStartName nicht mit nem Wert versehen( die funktion die das machen soll (MarshalString) sieht so aus:

void MarshalString ( System::String* s, std::string& os )
    {
    using namespace System::Runtime::InteropServices;
    const char* chars = (const char*)(Marshal::StringToHGlobalAnsi(s)).ToPointer();
    os = chars;
    Marshal::FreeHGlobal(IntPtr((void*)chars));
    }

( nicht von mir, hab ich in nem forum gefunden).

wenn ich jetzt in der line bevor das spiel aufgerufen wird anhalte( der andere aufruf funzt)( line 21), dann ist
GameStartName leer, und der entsprechende string im GameName array leer. Der Processaufruf bricht danach also ab, weil kein filename übergeben wird.

[haddock]

Wieso macht ihr das eigentlich so umständlich?
Genau für solche Sachen gibt es doch Skripte.

Würde in sh dann so aussehen:

#!/bin/sh
taktrathochfahrprogramm -parameter1 -parameter2
spielstart
taktratrunterfahrprogramm -parameter1 -parameter2

Bei Windows sollte das nicht deutlich komplexer sein.

[Daepilin]

Ich möchte damit auch meine c++ fähigkeiten verbessern. außerdem soll das ganze grundlage für einen gamelauncher/manager werden, wo die spiele mit icons in ner übersicht angezeigt und mit einem klick gestartet werden können

[haddock]

Wichtiger als C++-Kenntnisse waren für mich am Anfang diese zwei Regeln:
Regel 1: Nicht aufwendig, wenn es einfach geht
Regel 2: Tools am richtigen Ort einsetzen
Für jedes Spiel eine Bat-Skript in einen Ordner legen, Icon einstellen und schon habe ich die Funktionalität.

[Daepilin]

Ich weiß, so würde es gehen. aber es geht nich um die funktionalität, sondern um das lernen is ja auch nich so, dass es mich umbringt eben die verknüpfung vor und nach dem spiel auszuführen, aber darum gehts nicht.

[ojas]

void MarshalString ( System::String* s, std::string& os )
{
    using namespace System::Runtime::InteropServices;
    const char* chars = (const char*)(Marshal::StringToHGlobalAnsi(s)).ToPointer();
    os = chars;
    Marshal::FreeHGlobal(IntPtr((void*)chars));
}

Diese Funktion ist für dein Vorhaben nicht geeignet. Zum einen kopiert die Funktion von s nach os (und nicht wie du willst von os nach s). Zum anderen brauchst du überhaupt kein Marshalling. Marshalling brauchst du wenn du von unmanaged Code aus managed Code aufrufen willst. Das ist aber bei dir nicht der Fall.

System::String^ ToSystemString (const std::string& s)
{
    return gcnew System::String(s.c_str());
}

[Daepilin]

danke das dürfte der ganze fehler gewesen sein

edit: bei deinem code bekomme ich fehler:

1>GamesAndMore.cpp(10): error C3191: "^": Inkompatibel mit der /clrldSyntax-Befehlszeilenoption.
1>GamesAndMore.cpp(12): error C2065: 'gcnew': nichtdeklarierter Bezeichner
1>GamesAndMore.cpp(12): error C2143: Syntaxfehler: Es fehlt ';' vor 'System::String'
1>GamesAndMore.cpp(12): error C3604: "System::String": Nur ein verwaltetes Objekt kann auf dem gc-Heap erstellt werden.

[ojas]

1>GamesAndMore.cpp(10): error C3191: "^": Inkompatibel mit der /clr:oldSyntax-Befehlszeilenoption.

Ja, jetzt ergibt das auch plötzlich Sinn, dass du mit Zeigern arbeitest. Vor Visual C++ 2005 gab's nämlich kein C++/CLI, sondern nur Managed Extensions for C++ und da gab's noch keine Tracking Reference.

Entweder du steigst um auf C++/CLI und kompilierst ohne /clr:oldSyntax, oder

System::String ToSystemString (const std::string& s)
{
    return System::String(s.c_str());
}

Bei letzterem lohnt es sich aber kaum noch, eine eigene Funktion zu schreiben.