please help me in c language, i have following header files to help construct c files. Following code:

#ifndef DUNGEON$\_$INFO$\_$H

#define DUNGEON$\_$INFO$\_$H

#include

#include

#include "dungeon$\_$settings.h$"$

$//$This is the name we will use for our shared memory.

const char$*$ dungeon$\_$shm$\_$name $="/$DungeonMem$"$;

$//$These are the names for the levers when getting the treasure at the end.

const char$*$ dungeon$\_$lever$\_$one $="/$LeverOne$"$;

const char$*$ dungeon$\_$lever$\_$two $="/$LeverTwo$"$;

struct Barbarian$\{$

int attack;

$\}$;

struct Rogue$\{$

float pick;

$\}$;

struct Wizard$\{$

char spell$[$SPELL$\_$BUFFER$\_$SIZE$]$;

$\}$;

struct Barrier$\{$

char spell$[$SPELL$\_$BUFFER$\_$SIZE $+1]$;

$\}$;

struct Enemy$\{$

int health;

$\}$;

struct Trap$\{$

char direction;

bool locked;

$\}$;

struct Dungeon$\{$

bool running;

pid$\_$t dungeonPID;

struct Barbarian barbarian;

struct Rogue rogue;

struct Wizard wizard;

struct Barrier barrier;

struct Enemy enemy;

struct Trap trap;

char treasure$[4]$;

char spoils$[4]$;

$\}$;

$//$Call this method to begin running the dungeon. Valid pid's must be passed for it to work.

void RunDungeon$($pid$\_$t wizard, pid$\_$t rogue, pid$\_$t barbarian$)$;

#endif

#ifndef DUNGEON$\_$SETTINGS$\_$H

#define DUNGEON$\_$SETTINGS$\_$H

#include

$//$This specifies how many possible characters you can have in your spell buffer. It is a char array. Default: $100$

#define SPELL$\_$BUFFER$\_$SIZE $(100)$

$//$This is how many rounds the dungeon will play at a minimum. Default: $10$

#define NUM$\_$ROUNDS $(10)$

$//$This is how long the game will allow the rogue to try to guess the correct number for picking the lock. Default: $4$

#define SECONDS$\_$TO$\_$PICK $(4)$

$//$This is how many seconds the wizard will have to guess decode the message for the barrier. Default: $2$

#define SECONDS$\_$TO$\_$GUESS$\_$BARRIER $(2)$

$//$This is how long the barbarian has to attack the monster. Default: $2$

#define SECONDS$\_$TO$\_$ATTACK $(2)$

$//$This is the tolerance for guessing the rogue's pick. Lower values will be more difficult. Default: $2\mathrm{.}5$

#define LOCK$\_$THRESHOLD $(2\mathrm{.}5)$

$//$If true, the barbarian rounds can run. If false, barbarian rounds will not be run. Default: true

#define ALLOW$\_$BARBARIAN true

$//$If true, the rogue rounds can run. If false, rogue rounds will not be run. Default: true

#define ALLOW$\_$ROGUE true

$//$If true, the wizard rounds can run. If false, rogue rounds will not be run. Default: true

#define ALLOW$\_$WIZARD true

$//$How often the dungeon will check the value of the rogue's pick to see if the lock angle was guessed correctly.

$//$Lower values will increase the rate of checks, but will also put more messages in the terminal. Default: $10000$

#define TIME$\_$BETWEEN$\_$ROGUE$\_$TICKS $(10000)$

$//$The maximum angle used for the rogue's picking challenge. Default: $100$

#define MAX$\_$PICK$\_$ANGLE $(100)$

$//$This is the signal that the dungeon will use to communicate with user processes. Default: SIGUSR$1$

#define DUNGEON$\_$SIGNAL $($SIGUSR$1)$

$//$This is the signal that the dungeon will use to tell the processes to use their semaphores. Default: SIGUSR$2$

#define SEMAPH

The Barbarian

The Barbarian is the first character class that you should probably make. The Barbarian works as follows:

When the Barbarian receives a signal $($defined in dungeon$\_$settings. $h),$ the Barbarian copies the integer in the

enemy's health field into the attack field. Use dungeon$\_$info. $h$ to see how the Dungeon struct is set up$.$ The Dungeon

will then wait an amount of time defined in dungeon$\_$settings.h as SECONDS$\_$TO$\_$ATTACK. If the integer in attack

matches the integer in health, then this will count as success.

The Wizard

The Wizard is probably the second class that you should make. The Wizard works as follows:

When the Wizard receives a signal $($defined in dungeon$\_$settings. $h),$ the Wizard reads the Caesar Cypher placed in

the Barrier's spell field. The Wizard then decodes the Caesar Cypher, using the first character as the key, and copies

the decoded message into the Wizard's spell field. The Dungeon will wait an amount of time defined in

dungeon$\_$settings.h as SECONDS$\_$TO$\_$GUESS$\_$BARRIER for the decoding process to complete. If the Wizard's spell

field matches the decoded message after the Dungeon has finished waiting, then this will count as success.

The Rogue

The Rogue is probably the last class that you should make. The Rogue works as follows:

When the Rogue receives a signal $($defined in dungeon$\_$settings. $h),$ the Rogue will attempt to guess a float value to

"pick" a lock. The Trap struct has a char for direction, and a boolean for locked. This puzzle is a little unique. The

Dungeon will wait for a total amount of time defined in dungeon$\_$settings. $h$ as SECONDS$\_$TO$\_$PICK, but will check

the value of the Rogue's current pick position using TIME$\_$BETWEEN$\_$ROGUE$\_$TICKS. Notice that these two values are

quite different, and that is because one of them uses sleep, and the other usleep. I recommend that you follow a

similar example.