0

RPG.stackexchangeからリンクするためにここに投稿しています。

私は、大規模な軍隊が互いに投げつけられるパスファインダーゲームを実行しています。物事をスピードアップするために私が見た提案の 1 つは、ボード ゲームであるリスクのルールを使用することです。

しかし、リスクのルールは、単位が等しい価値を持つことを前提としています。いずれかの軍隊のサイコロを d6 から d8 に変更するとどうなりますか?

同様の質問への回答は非常によく考えられていますが、マイナーなルールの変更を伴う「もしも」の質問には向いていません。そして、数学者がしつこいことを評価するとは思えません。

(余談ですが、R でプログラミングを学ぼうとするのは、統計をしっかりと把握していなければ難しいものです。R の構文を知っていれば、線形モデルを適合させる方法がわかるわけではありません。)

それで、stackoverflow、Risk (ボードゲーム) シミュレーターを持ってきて、計算に慣れるまでルールセットをいじることができます。

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 に答える