#include
#include
#include
#include
// Zdefiniuj strukturę pytań
typedef struct {
pytanie Char [256];
Odpowiedź char [256];
Char Option1 [256];
Char Option2 [256];
Char Option3 [256];
Char Option4 [256];
} Pytanie;
// Zdefiniuj strukturę stanu gry
typedef struct {
int Current Question;
intwon;
int lifelineused [3]; // 0 dla nieużywanych, 1 dla używanych
int gameover;
} GameState;
// funkcja ładowania pytań z pliku
Pytanie* ładowanie (const char* nazwa pliku, int* nurkestions) {
Plik* fp =fopen (nazwa pliku, „r”);
if (fp ==null) {
printf („Plik pytania otwierającego błąd! \ n”);
powrót NULL;
}
// Przeczytaj liczbę pytań
fscanf (fp, „%d \ n”, nurtquestions);
// Przydziel pamięć na pytania
Pytanie* Pytania =Malloc (* nurtquestions* sizeof (pytanie));
if (pytania ==null) {
printf („Błąd przydzielanie pamięci na pytania! \ n”);
fclose (FP);
powrót NULL;
}
// Przeczytaj pytania z pliku
for (int i =0; i <*nurtquestions; i ++) {
fscanf (fp, „%[^\ n] \ n”, pytania [i] .Question);
fscanf (fp, „%[^\ n] \ n”, pytania [i] .AnSwer);
fscanf (fp, „%[^\ n] \ n”, pytania [i] .option1);
fscanf (fp, „%[^\ n] \ n”, pytania [i] .option2);
fscanf (fp, „%[^\ n] \ n”, pytania [i] .option3);
fscanf (fp, „%[^\ n] \ n”, pytania [i] .option4);
}
fclose (FP);
pytania zwrotne;
}
// funkcja wyświetlania bieżącego pytania
void displayquestion (pytanie pytanie) {
printf ("\ n%s \ n \ n", pytanie. Question);
printf („1 %s \ n”, pytań.option1);
printf („2. %s \ n”, pytanie.option2);
printf („3. %s \ n”, pytanie.option3);
printf („4. %s \ n”, pytanie.option4);
}
// Funkcja do obsługi odpowiedzi gracza
int getanswer (gra gameState*) {
int odpowiedź;
printf („\ nenter twoja odpowiedź (1-4):”);
Scanf („%d” i odpowiedź);
// sprawdź odpowiedź
while (odpowiedź <1 || Odpowiedź> 4) {
printf („Nieprawidłowa odpowiedź! Wprowadź numer od 1 do 4:”);
Scanf („%d” i odpowiedź);
}
Zwróć odpowiedź;
}
// Funkcja, aby sprawdzić, czy odpowiedź jest poprawna
int Checkanswer (pytanie pytanie, int odpowiedź) {
if (odpowiedź ==1 &&strcmp (pytanie.option1, pytanie.answer) ==0) {
zwrot 1;
} else if (odpowiedź ==2 &&strcmp (aspekt.option2, pytanie.answer) ==0) {
zwrot 1;
} else if (odpowiedź ==3 &&strcmp (aspekt.option3, pytanie.answer) ==0) {
zwrot 1;
} else if (odpowiedź ==4 &&strcmp (aspten.option4, pytanie.answer) ==0) {
zwrot 1;
} w przeciwnym razie {
powrót 0;
}
}
// Funkcja do obsługi linii ratunkowych
void uselifeline (gamestate* gra) {
wybór int;
printf („\ n, w którym LIFELINE chciałbyś użyć? \ n”);
printf („1. 50/50 \ n”);
printf („2. Zapytaj publiczność \ n”);
printf („3. Zadzwoń do przyjaciela \ n”);
printf („Wprowadź swój wybór (1-3):”);
Scanf („%d” i wybór);
// sprawdź wybór
while (wybór <1 || wybór> 3) {
printf („Nieprawidłowy wybór! Wprowadź numer od 1 do 3:”);
Scanf („%d” i wybór);
}
// Sprawdź, czy linia ratunkowa jest już używana
if (game-> lifelineUd [wybór - 1] ==1) {
printf („Użyłeś już tej linii ratunkowej! \ n”);
powrót;
}
// Wdrożenie logiki Lifeline tutaj (np. Usuń nieprawidłowe opcje, symuluj głosowanie odbiorców itp.)
game-> lifelineused [wybór - 1] =1;
printf („Lifeline używana pomyślnie! \ n”);
}
// Funkcja gry w grę
void PlayGame (pytanie* pytania, int nurkestions) {
Gra GameState;
game.currentQuestion =0;
game.moneywon =0;
memset (game.lifelineused, 0, sizeof (game.lifelineused));
game.gameover =0;
while (! game.gameover) {
// Wyświetl bieżące pytanie
Displayquestion (pytania [game.currentQuestion]);
// obsługa linii ratunkowej
printf ("\ ndo chcesz użyć linii ratunkowej? (y/n):");
Char LifeLineChoice;
Scanf („ %C” i LifeLineChoice);
if (LifeLineCoice =='y') {
Uselifeline (i gra);
}
// Zdobądź odpowiedź gracza
int odpowiedź =getanswer (i gra);
// Sprawdź, czy odpowiedź jest poprawna
if (CheckansWer (pytania [game.currentQuestion], odpowiedź)) {
printf ("poprawne! \ n");
game.moneywon + =1000 * (game.currentQuestion + 1);
game.currentQuestion ++;
if (game.currentQuestion ==Numquestions) {
game.gameover =1;
printf ("\ ncongratulations! Wygrałeś $%d! \ n", game.moneywon);
przerwa;
}
} w przeciwnym razie {
printf („niepoprawny! \ n”);
game.gameover =1;
printf („\ nyou wygrał $%d. więcej szczęścia następnym razem! \ n”, game.moneywon);
przerwa;
}
}
}
int main () {
SRAND (czas (null));
int nurt;
Pytanie* Pytania =ładowanie („pytania
if (pytania ==null) {
zwrot 1;
}
printf („\ nwelcome to, kto chce być milionerem! \ n”);
PlayGame (pytania, mnóstwo);
darmowe (pytania);
powrót 0;
}
`` `
Jak używać tego kodu:
1. Utwórz plik pytania: Utwórz plik tekstowy o nazwie „pytania
`` `
10 // Liczba pytań
Jaka jest stolica Francji? // Pytanie
Paryż // poprawna odpowiedź
Berlin // opcja 1
Londyn // opcja 2
Rzym // Opcja 3
Tokyo // opcja 4
... // Dodaj więcej pytań w tym samym formacie
`` `
2. skompiluj i uruchom: Skompiluj kod za pomocą kompilatora C (np. GCC) i uruchom wykonywalny.
Objaśnienie:
* Struktury danych:
* `` Pytanie 'Struktura:przechowuje tekst pytania, odpowiedź i opcje wielokrotnego wyboru.
* `` GameState` Struktura:śledzi bieżące pytanie, wygrane pieniądze, użyte linie ratunkowe i status gry.
* funkcje:
* `Loadquestions ()`:Ładuje pytania z pliku.
* `Displayquestion ()`:Wyświetla bieżące pytanie i opcje.
* `GetAnSwer ()`:Monituje gracza o odpowiedź i weryfikuje dane wejściowe.
* `Checkanswer ()`:Porównuje odpowiedź gracza z poprawną odpowiedzią.
* `uselifeline ()`:Obsługuje wybór i implementację linii życia (symbol zastępczy dla faktycznej logiki życia).
* `PlayGame ()`:zarządza główną pętlą gry, obsługą pytań, odpowiedzi i linii ratunkowych.
* logika gry:
* Funkcja „PlayGame () iteruje pytania, dopóki gracz nie osiągnie ostatecznego pytania lub odpowiedzi niepoprawnie.
* Gracz może korzystać z linii ratunkowych, wybierając opcje z menu.
* Gra śledzi postępy gracza i wygrane pieniądze.
Aby zaimplementować linię ratunkową, musisz dodać następujące w funkcji „uselifeline ():
* 50/50: Usuń losowo dwie niepoprawne opcje.
* Zapytaj publiczność: Generuj losowe głosy odbiorców, co daje poprawnej odpowiedzi większą szansę na wygraną.
* Zadzwoń do przyjaciela: Wygeneruj losową odpowiedź „przyjaciela”, która może być poprawna lub nieprawidłowa z pewnym prawdopodobieństwem.
Ten kod stanowi podstawową strukturę dla gry „Who chce być milionerem”. Możesz go wzmocnić dalej:
* Wdrożenie bardziej zaawansowanej logiki Lifeline.
* Dodanie elementów wizualnych i animacji.
* Uwzględnienie bardziej złożonych formatów pytań.
* Oszczędzanie i ładowanie postępu gry.