0

我在此处发布此链接以链接到RPG.stackexchange。

我正在运行一个探路者游戏，该游戏将有大量军队相互对抗。我看到的加快速度的建议之一是使用棋盘游戏 Risk 的规则。

但是风险规则假设单位是等值的。如果将其中一支军队的骰子从 d6 改为 d8，会发生什么？

类似问题的答案，虽然经过深思熟虑，但不适用于规则更改较小的“假设”问题。我怀疑数学家会欣赏这种纠缠。

（另外，顺便说一句，如果你对统计学没有扎实的掌握，那么尝试学习 R 编程是很困难的。这不像知道 R 的语法会告诉你如何拟合线性模型。）

所以，stackoverflow，给我一个风险（棋盘游戏）模拟器，我可能会摆弄规则集，直到我对它的计算感到满意。

4

1 回答 1

1

是的先生，当然先生，马上先生。

//Experimenting with Risk variant
//Because figuring out the actual mathmatics behind this is hard.

#include <time.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#define MIN(a,b) (((a)<(b))?(a):(b))
#define MAX(a,b) (((a)>(b))?(a):(b))

//#define DISTRUSTRAND 1
//#define VERBOSE 1


int g_rollArray[100];

int compare (const void * a, const void * b)
{
  return ( *(int*)b - *(int*)a );
}



int diceRoll(int dieSize)
{
  int roll = rand()%(dieSize-1);
  g_rollArray[roll]++;
  return roll+1;
}


// MAIN!
int main( int argc, char* args[] )
{
  int seed;
  int maxRound=100000;  //Some arbitrarily large number.
  int round=0;
  int i;

  memset(g_rollArray,0,sizeof(int)*100);

  //Hmmm, there could be a mix of troops, but right now, let's say it's uniform.
  const int numAtt = 3; //How many troops they bring into the fight, that's how many dice they roll
  const int powAtt = 8; //The size of the dice they roll. Like d4, d6, d8.  
  int rollAtt[numAtt];

  const int numDef = 2; //How many troops they bring into the fight, that's how many dice they roll
  const int powDef = 6; //The size of the dice they roll. Like d4, d6, d8.  
  int rollDef[numDef];

  int lossAtt=0;  //Assuming a big-ass pool of troops behind them. Whoever runs out of a pool first loses.
  int lossDef=0;


  seed = time(0);
  srand(time(0));
  printf("seed: %d\n",seed);

  #ifdef DISTRUSTRAND
  for(i=0; i<10; i++)
  {
    printf("%d: %d\n",i, rollArray[i]);
  }
  #endif

  for(round=0; round<maxRound; round++)
  {
    for(i=0; i<numAtt; i++)
    {
      rollAtt[i] = diceRoll(powAtt);
    }
    for(i=0; i<numDef; i++)
    {
      rollDef[i] = diceRoll(powDef);
    }

    qsort (rollAtt, numAtt, sizeof(int), compare);
    qsort (rollDef, numDef, sizeof(int), compare);

    #ifdef VERBOSE
      printf("sort Att: ");
      for(i=0; i<numAtt; i++)
      {
        printf("%d ",rollAtt[i]);
      }
      printf("\n");

      printf("sort Def: ");
      for(i=0; i<numDef; i++)
      {
        printf("%d ",rollDef[i]);
      }
      printf("\n");
    #endif


    //The MIN here decrees that armies can only lose the forces they commit to a fight
    for(i=0; i<MIN(numDef,numAtt); i++)
    {
      #ifdef VERBOSE
        printf("Comp: %d Vs %d \n",rollAtt[i], rollDef[i]);
      #endif
      //Defenders win ties
      if(rollAtt[i] > rollDef[i])
      {
        lossDef++;
      }
      else
      {
        lossAtt++;
      }
    }
  }


  printf("Att losses: %d \n",lossAtt);
  printf("Def losses: %d \n",lossDef);

  if(lossAtt > lossDef)
  {
    printf("Odds to win: Defender \nKill ratio: %f\n", (float)lossAtt/(float)lossDef);
  }
  else
  {
    printf("Odds to win: Attacker \nKill ratio: %f\n", (float)lossDef/(float)lossAtt);
  }

  #ifdef DISTRUSTRAND
  for(i=0; i<10; i++)
  {
    printf("%d: %d\n",i, rollArray[i]);
  }
  #endif
  return 0;
}  


/* meh, unneeded, mingw's rand()%whatnot works well enough.
int betterRand(int n)
{
  return rand() / (RAND_MAX / n + 1);
}

float betterFRand(float n)
{
  return (float)rand()/((float)RAND_MAX/n);
}
*/

虽然最初的风险规则集只为攻击者提供了大约 8% 的优势，这相当于大约 1:1.06 的杀伤率，但事实证明，如果你改变骰子大小，几率会很快发生变化。给攻击者 d8，给他们 1:3 的杀伤率。也就是说，掷出 1-8 的军队有机会击败只掷出 1-6 但规模是其 3 倍的军队。

如果你在军队之间保持骰子大小均匀，但增加它，随着平局的影响减少，几率会稍微转移到攻击者身上

增加模具辊的数量比增加模具辊的尺寸具有更微妙的影响。拥有 3 个 d6 的防御者略好于拥有 2 个 d8 的攻击者。

所以总而言之，对于任何想要玩弄风险规则并看看结果如何的 DM 来说，这都是一个很好的起点。

希望一旦我把头绕在 R 上，我会用图表和东西得到更好的答案。

于 2013-06-26T22:03:29.040 回答