Arrays 以30%的概率动态分配和初始化新对象

我正在编写一个程序，模拟攀登一座山的跑步者之间的随机比赛，矮人兽人（DORC）正从山上下来攻击跑步者。它开始于两个名为哈罗德和蒂米的赛跑者在山脚下。跑步者以随机移动的方式上山，他们可以向山上前进，也可以滑回山下。DORC是随机生成的，如果碰撞，它们会对跑步者造成伤害。当其中一名跑步者到达山顶或两名跑步者都死亡时，模拟结束

我正在努力实现一个真正的比赛循环。一旦竞赛被初始化，竞赛循环将迭代，直到竞赛结束。当宣布获胜者或所有参赛者死亡时，就会发生这种情况

竞赛循环的每次迭代都将执行以下操作：

以30%的概率，动态分配一个新的dorc作为EntityType结构，并按如下方式初始化它：

（a） dorc的化身总是“d”

（b） 每个dorc在第2排的山顶开始比赛

（c） 以相同的概率，dorc可能与timmy位于同一列中，或与harold位于同一列中，或正好位于两者中间的列中

（d） 将新的dorc添加到种族的dorc数组中

（e） 使用pthread_create（）函数，为新的dorc创建一个线程，并将线程指针保存在dorc的实体结构中；每个dorc线程将执行的函数是void*goDorc（void*）函数，您将在后面的步骤中实现该函数；goDorc（）函数的参数将是对应于该dorc的EntityType指针

我想我对如何处理这个问题的逻辑感到困惑。我决定创建一个名为isOver（）的函数来指示竞争是否结束，然后创建一个名为addDorc（）的单独函数来初始化Dorc元素并执行上述所有要求

在isOver（）中，我尝试通过执行

addDorc（race）将一个dorc对象添加到dorcs数组中在每次竞赛循环迭代中/如果竞赛尚未结束或无人死亡。但我一直在犯错误：

control.c:82:3: error: too few arguments to function ‘addDorc’
   addDorc(race);

问题是我不认为我可以手动声明addDorc（）中的所有参数，因为像“path”参数这样的一些元素是基于概率的。如上所述，以相同的概率，dorc可能与timmy位于同一列中，或与harold位于同一列中，或正好位于两者中间的列中。问题是在调用addDorc（）时，我不知道如何计算这个随机值，希望能得到一些帮助。我也不知道我是否正确地执行了“以30%的概率，动态地分配一个新的dorc作为EntityType结构”，如果您能提供一些相关信息，我将不胜感激

defs.h

typedef struct {
  pthread_t thr;
  char avatar[MAX_STR];
  int  currPos; 
  int  path; 
} EntityType;

typedef struct {
  EntityType ent;
  char name[MAX_STR];
  int  health;
  int  dead; 
} RunnerType;

typedef struct {
  int numRunners;
  RunnerType *runners[MAX_RUNNERS];  
  int numDorcs;
  EntityType *dorcs[MAX_DORCS]; 
  char winner[MAX_STR]; 
  int  statusRow; 
  sem_t mutex;
} RaceInfoType;

void launch();
int addDorc(RaceInfoType*, char*, int, int);
int isOver(RaceInfoType*);
void initRunners(RaceInfoType*);
int addRunner(RaceInfoType*, char*, char*, int, int, int, int);

int  randm(int);

void *goRunner(void*);
void *goDorc(void*);

RaceInfoType *race;

控制

void launch(){

    race = malloc(sizeof(RaceInfoType));
    race->numRunners = 0;
    
    initRunners(race);
    
    if (sem_init(&race->mutex, 0, 1) < 0) {
        printf("semaphore initialization error\n");
        exit(1);
    }
    
    strcpy(race->winner, " ");
    
    
    srand((unsigned)time(NULL));
    
    int i;
    for(i = 0; i < race->numRunners; ++i){
        pthread_create(&(race->runners[i]->ent.thr), NULL, goRunner, " ");
    }
    
    race->numDorcs = 0;
}



int addDorc(RaceInfoType* race, char *avatar, int path, int currPos){ 
    if(race->numDorcs == MAX_DORCS){ 
        printf("Error: Maximum dorcs already reached. \n");
        return 0;
    }       
    race->dorcs[race->numDorcs] = malloc(sizeof(EntityType));
    
    int timmysColumn = race->dorcs[race->numDorcs]->currPos;
    int haroldsColumn = race->dorcs[race->numDorcs]->currPos;
    int halfwayColumn = (timmysColumn+haroldsColumn)/2;
    
    int r = rand()%100;
    
    pthread_t dorc;
    
    if(r <= 30){
        strcpy(race->dorcs[race->numDorcs]->avatar, "d");
        race->dorcs[race->numDorcs]->currPos = 2;
        if(r <= 33){
            race->dorcs[race->numDorcs]->path = timmysColumn;
        }else if(r <= 66){
            race->dorcs[race->numDorcs]->path = haroldsColumn;
        }else{
            race->dorcs[race->numDorcs]->path = halfwayColumn;
        }
        pthread_create(&dorc, NULL, goDorc, " ");
    }
    race->numRunners++;
}

int isOver(RaceInfoType* race){ 
    int i;
    for(i = 0; i < race->numRunners; ++i){
        if((race->winner != " ") || (race->runners[race->numRunners]->dead = 1)){
            return 1;
        }
        addDorc(race);
        return 0;
    }
}
void initRunners(RaceInfoType* r){
    addRunner(r, "Timmy", "T", 10, 35, 50, 0); 
    addRunner(r, "Harold", "H", 14, 35, 50, 0); 
}


int addRunner(RaceInfoType* race, char *name, char *avatar, int path, int currPos, int health, int dead){
    if(race->numRunners == MAX_RUNNERS){ 
        printf("Error: Maximum runners already reached. \n");
        return 0;
    }       
    race->runners[race->numRunners] = malloc(sizeof(RunnerType));
    strcpy(race->runners[race->numRunners]->name, name);
    strcpy(race->runners[race->numRunners]->ent.avatar, avatar);
    race->runners[race->numRunners]->ent.path = path;
    race->runners[race->numRunners]->ent.currPos = currPos;
    race->runners[race->numRunners]->health = health;
    race->runners[race->numRunners]->dead = dead;
    race->numRunners++;
    return 1;
}

void launch（）{
race=malloc（sizeof（RaceInfoType））；
race->numRunners=0；
跑步者（比赛）；
if（sem_init（&race->mutex，0，1）<0）{
printf（“信号量初始化错误\n”）；
出口（1）；
}
strcpy（比赛->获胜者“）；
srand（（无符号）时间（NULL））；
int i；
对于（i=0；inumRunners；++i）{
pthread_create（&（race->runners[i]->ent.thr），NULL，goRunner，“”）；
}
race->numDorcs=0；
}
int addDorc（RaceInfoType*race，char*avatar，int path，int currPos）{
如果（race->numDorcs==MAX_DORCS）{
printf（“错误：已达到最大DORC。\n”）；
返回0；
}       
race->dorcs[race->numDorcs]=malloc（sizeof（EntityType））；
int timmysColumn=race->dorcs[race->numDorcs]->currPos；
int haroldsColumn=race->dorcs[race->numDorcs]->currPos；
int halfwayColumn=（timmysColumn+haroldsColumn）/2；
int r=rand（）%100；
pthread_t dorc；
如果（r-dorcs[race->numDorcs]->avatar，“d”）；
race->dorcs[race->numDorcs]->currPos=2；
if（r dorcs[race->numDorcs]->path=timmysColumn；
}else if（r dorcs[race->numDorcs]->path=haroldsColumn；
}否则{
race->dorcs[race->numDorcs]->path=halfwayColumn；
}
pthread_create（&dorc，NULL，goDorc，“”）；
}
种族->numRunners++；
}
int isOver（RaceInfoType*race）{
int i；
对于（i=0；inumRunners；++i）{
如果（（比赛->赢家！=“”）| |（比赛->跑步者[比赛->跑步者]->死亡=1））{
返回1；
}
addDorc（种族）；
返回0；
}
}
void initRunners（RaceInfoType*r）{
addRunner（r，“Timmy”，“T”，10,35,50,0）；
addRunner（r，“Harold”，“H”，14,35,50,0）；
}
int addRunner（RaceInfoType*race，char*name，char*avatar，int path，int currPos，int health，int dead）{
如果（比赛->最大跑步者==最大跑步者）{
printf（“错误：已达到最大运行次数。\n”）；
返回0；
}       
种族->跑步者[种族->跑步者]=malloc（sizeof（RunnerType））；
strcpy（种族->跑步者[种族->跑步者]->姓名；
strcpy（race->runners[race->numRunners]->ent.avatar，avatar）；
race->runners[比赛->numRunners]->ent.path=path；
种族->跑步者[种族->跑步者]->ent.currPos=currPos；
种族->跑步者[种族->跑步者]->健康=健康；
种族->跑步者[种族->跑步者]->死亡=死亡；
种族->numRunners++；
返回1；
}
警告：由于缺少太多[未编写的]代码，这不是一个完整的解决方案

但是，我注意到至少有两个bug：我的顶部评论中的
isOver
bug，以及
addDorc
中的递增
race->numRunners

isOver
还有
返回0；
放错了[在循环中]。这应该作为函数中的最后一条语句。如果您使用
-Wall
[您应该始终这样做]编译，则应该由
EntityType *ent = &race->dorcs[race->numDorcs];
ent->whatever = ...;

void
launch(void)
{

    race = malloc(sizeof(RaceInfoType));
    race->numRunners = 0;

    initRunners(race);

    if (sem_init(&race->mutex,0,1) < 0) {
        printf("semaphore initialization error\n");
        exit(1);
    }

    strcpy(race->winner," ");

    srand((unsigned)time(NULL));

    int i;
    for (i = 0;  i < race->numRunners;  ++i) {
        RunnerType *run = &race->runners[i];
        EntityType *ent = &run->ent;
        pthread_create(&ent->thr,NULL,goRunner,ent);
    }

    race->numDorcs = 0;
}

int
addDorc(RaceInfoType* race,char *avatar,int path,int currPos)
{
    if (race->numDorcs == MAX_DORCS) {
        printf("Error: Maximum dorcs already reached. \n");
        return 0;
    }

    EntityType *ent = malloc(sizeof(*ent));
    race->dorcs[race->numDorcs] = ent;

    int timmysColumn = ent->currPos;
    int haroldsColumn = ent->currPos;
    int halfwayColumn = (timmysColumn + haroldsColumn) / 2;

    int r = rand()%100;

#if 0
    pthread_t dorc;
#endif

    if (r <= 30) {
        strcpy(ent->avatar,"d");
        ent->currPos = 2;
        if (r <= 33) {
            ent->path = timmysColumn;
        } else if (r <= 66) {
            ent->path = haroldsColumn;
        } else {
            ent->path = halfwayColumn;
        }
        pthread_create(&ent->thr,NULL,goDorc,ent);
    }

#if 0
    race->numRunners++;
#else
    race->numDorcs += 1;
#endif
}

int
isOver(RaceInfoType* race)
{
    int i;

    for (i = 0;  i < race->numRunners;  ++i) {
#if 0
        if ((race->winner != " ") ||
            (race->runners[race->numRunners]->dead = 1))
            return 1;
#else
        RunnerType *run = &race->runners[i];
        if ((race->winner != " ") || (run->dead == 1))
            return 1;
#endif
        addDorc(race);
#if 0
        return 0;
#endif
    }

#if 1
    return 0;
#endif
}

void
initRunners(RaceInfoType* r)
{
    addRunner(r,"Timmy","T",10,35,50,0);
    addRunner(r,"Harold","H",14,35,50,0);
}

int
addRunner(RaceInfoType* race,char *name,char *avatar,int path,int currPos,
    int health,int dead)
{

    if (race->numRunners == MAX_RUNNERS) {
        printf("Error: Maximum runners already reached. \n");
        return 0;
    }

    RunnerType *run = malloc(sizeof(*run));
    race->runners[race->numRunners] = run;

    strcpy(run->name,name);

    EntityType *ent = &run->ent;
    strcpy(ent->avatar,avatar);
    ent->path = path;
    ent->currPos = currPos;

    run->health = health;
    run->dead = dead;

    race->numRunners++;

    return 1;
}

#if 0
// old code
#else
// new code
#endif

#ifdef NEVERWAS
// old code ...
#else
// new code
#endif