jeopardy 0.0.26

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3f2e4ec7a88258a44bd43c227c69e7fea652b1ad
+  data.tar.gz: 687ee8d39fcc775e55d3f373ed5fbb1f31fe69d4
+SHA512:
+  metadata.gz: e09c4d840e98e26241e9a759c893a50310285115de97b17dc57d7bd07105e2c2bf578684fabaab58838d3a93358d90b8f7b716f6f84645c3e6366e45e501c9f0
+  data.tar.gz: d4b0a0d3aa98c4310a3aed295373ac629ba1bf2b4115669af8e6b46336c1c54c15a7898a8863a21180df1b726e40661c37f9c9220f249a4e684212034e4f1736

data/ext/jeopardy/Clue.c

@@ -0,0 +1,99 @@
+//Clue.c
+#include "Clue.h"
+#include <string.h>
+#include <stdlib.h>
+#include <math.h>
+#include "ruby.h"
+#include "MinMax.h"
+
+double sampleNormal()
+{
+    double u, v, r;
+    do
+    {
+        u = drand() * 2.0 - 1.0;
+        v = drand() * 2.0 - 1.0;
+        r = u * u + v * v;
+    } while (r == 0.0 || r > 1.0);
+    double c = sqrt(-2.0 * log(r) / r);
+    return u * c;
+}
+
+Clue clueMake(int value, int round, int row, int column, int isDailyDouble)
+{
+	Clue clue;
+	clue.value = value;
+	clue.round = round;
+	clue.row = row;
+	clue.column = column;
+	clue.isDailyDouble = isDailyDouble;
+	clueReset(&clue);
+	return clue;
+}
+
+void clueReset(Clue *clue)
+{
+    for (int j = 0; j<3; j++)
+    {
+        clue->answers[j] = NO_ANSWER;
+        clue->wagers[j] = NO_WAGER;
+    }
+    if (clue->round == 3)
+    {
+        clue->finalJeopardyStandardDeviations = sampleNormal();
+    }
+}
+
+int previousAnswerers(Clue *clue)
+{
+	return (clue->answers[0] > -1) + (clue->answers[1] > -1) + (clue->answers[2] > -1);
+}
+
+double rawOddsOfAnsweringClue(Clue *clue)
+{
+	const double odds[2][3][5] = {
+		{
+			{0.9316826244,	0.9020692974,	0.8808619551,	0.8568982492,	0.8262623452}, 
+			{0.9344023324,	0.9148061105,	0.8989547038,	0.8820861678,	0.8332403793},
+      {0.9861111111,	0.9428571429,	0.9482758621,	0.9449541284,	0.9761904762}
+    },
+    {
+      {0.9191489362,	0.8851981352,	0.846296456,	0.8150716176,	0.7819324269},
+      {0.9168356998,	0.8936294565,	0.8767288034,	0.8435064935,	0.8086092715},
+      {0.972972973,	0.9652173913,	0.9595959596,	0.9368421053,	0.9444444444}
+    }
+  };
+	return odds[clue->round - 1][previousAnswerers(clue)][clue->row];
+}
+
+double rawOddsOfAnsweringDailyDouble(Clue *clue)
+{
+  const double odds[2][5] = {
+    {0.76, 0.7364864865, 0.7255985267, 0.6594800254, 0.6321167883},
+    {0.75, 0.7361647362, 0.6603773585, 0.6360884045, 0.5720502901}
+  };
+	return odds[clue->round - 1][clue->row];
+}
+
+double rawOddsOfRingingIn(Clue *clue)
+{
+	const double odds[2][3][5] = {
+    {
+      {0.726542166,  0.6600194005,  0.6006297272,  0.5522971451,  0.4693421163}, 
+      {0.5396228103,  0.4495181174,  0.3649201599,  0.3127371374,  0.2778616104}, 
+      {0.8,  0.724137931,  0.6666666667,  0.5240384615,  0.2809364548}
+    }, 
+    {
+      {0.6867450161,  0.6042841339,  0.5466591934,  0.4895921923,  0.3971898935}, 
+      {0.4845967439,  0.3838645318,  0.2695752355,  0.2125177663,  0.1979007232}, 
+      {0.6016260163,  0.6318681319,  0.4829268293,  0.3941908714,  0.3114186851}
+    }
+  };
+	return odds[clue->round - 1][previousAnswerers(clue)][clue->row];
+}
+
+double rawOddsOfAnsweringFinalJeopardy(Clue *finalJeopardy)
+{
+	return finalJeopardy->finalJeopardyStandardDeviations*0.22 + 0.4924242424;
+}
+

data/ext/jeopardy/Clue.h

@@ -0,0 +1,35 @@
+//Clue.h
+#include <limits.h>
+
+#ifndef CLUE_H
+#define CLUE_H
+
+typedef enum
+{
+	NO_WAGER = INT_MIN,
+	NO_ANSWER,
+	CORRECT_ANSWER,
+	INCORRECT_ANSWER
+} ResponseType;
+
+typedef struct
+{
+	int value;
+	int round;
+	int row;
+	int column;
+	int isDailyDouble;
+	double finalJeopardyStandardDeviations;
+	int answers[3];
+	int wagers[3];
+} Clue;
+
+Clue clueMake(int value, int round, int row, int column, int isDailyDouble);
+
+double rawOddsOfAnsweringClue(Clue *clue);
+double rawOddsOfAnsweringDailyDouble(Clue *clue);
+double rawOddsOfRingingIn(Clue *clue);
+double rawOddsOfAnsweringFinalJeopardy(Clue *finalJeopardy);
+void clueReset(Clue *clue);
+double randomFJPercentage();
+#endif

data/ext/jeopardy/Game.c

@@ -0,0 +1,413 @@
+//Game.c
+
+#include "Game.h"
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+#include "MinMax.h"
+#include <stdio.h>
+
+Game gameMake(Player *players, int numJeopardyClues, Clue *jeopardyClues, int numDoubleJeopardyClues, Clue *doubleJeopardyClues, Clue finalJeopardyClue, int playerInControlIndex)
+{
+	Game game;
+	memcpy(game.players, players, sizeof(game.players));
+	game.numJeopardyClues = numJeopardyClues;
+	game.jeopardyClues = malloc(sizeof(Clue)*numJeopardyClues);
+	memcpy(game.jeopardyClues, jeopardyClues, sizeof(Clue)*numJeopardyClues);
+	game.doubleJeopardyClues = malloc(sizeof(Clue)*numDoubleJeopardyClues);
+	memcpy(game.doubleJeopardyClues, doubleJeopardyClues, sizeof(Clue)*numDoubleJeopardyClues);
+	game.numDoubleJeopardyClues = numDoubleJeopardyClues;
+	game.finalJeopardyClue = finalJeopardyClue;
+	game.playerInControlIndex = playerInControlIndex;
+	return game;
+}
+
+void gameFree(Game game)
+{
+    free(game.jeopardyClues);
+    free(game.doubleJeopardyClues);
+}
+
+void resetDailyDoubles(Game *game)
+{
+	int numJeopardyDailyDoubles = 0;
+	for (int i = 0; i<game->numJeopardyClues; i++)
+	{
+		numJeopardyDailyDoubles += game->jeopardyClues[i].isDailyDouble;
+	}
+
+	int numDoubleJeopardyDailyDoubles = 0;
+	for (int i = 0; i<game->numDoubleJeopardyClues; i++)
+	{
+		numDoubleJeopardyDailyDoubles += game->doubleJeopardyClues[i].isDailyDouble;
+	}
+	
+	for (int i = 0; i<game->numJeopardyClues; i++)
+	{
+		game->jeopardyClues[i].isDailyDouble = 0;
+	}
+	
+	for (int i = 0; i<game->numDoubleJeopardyClues; i++)
+	{
+		game->doubleJeopardyClues[i].isDailyDouble = 0;
+	}
+	
+	if (numJeopardyDailyDoubles)
+	{
+		addDailyDouble(game, 1);
+	}
+
+	for (int i = 0; i<numDoubleJeopardyDailyDoubles; i++)
+	{
+		addDailyDouble(game, 2);
+	}
+}
+
+void gameReset(Game *game, int *scores)
+{	
+    for (int i = 0; i<3; i++)
+    {
+        game->players[i].score = scores[i];
+    }
+    
+    for (int i = 0; i<game->numJeopardyClues; i++)
+    {
+        Clue *clue = &game->jeopardyClues[i];
+        clueReset(clue);
+    }
+    
+    for (int i = 0; i<game->numDoubleJeopardyClues; i++)
+    {
+        Clue *clue = &game->doubleJeopardyClues[i];
+        clueReset(clue);
+    }
+    
+		shuffleClues(game->jeopardyClues, game->numJeopardyClues);
+		shuffleClues(game->doubleJeopardyClues, game->numDoubleJeopardyClues);
+		
+    clueReset(&game->finalJeopardyClue);
+    game->playerInControlIndex = 0;
+		
+		resetDailyDoubles(game);
+    
+}
+
+Game averageGame()
+{
+    Player players[3] = {averagePlayer(), averagePlayer(), averagePlayer()};
+    int numClues = 30;
+    Clue jClues[numClues];
+    Clue djClues[numClues];
+    for (int i = 0; i<numClues; i++)
+    {
+        int value = (i%5+1)*200;
+        jClues[i] = clueMake(value, 1, i%5, i/5, 0);
+        djClues[i] = clueMake(value*2, 2, i%5, i/5, 0);
+    }
+    Clue fjClue = clueMake(0, 3, 0, 0, 0);
+    Game game = gameMake(players, numClues, jClues, numClues, djClues, fjClue, 0);
+    game.previousDailyDoubleColumn = -1;
+    addDailyDouble(&game, 1);
+    addDailyDouble(&game, 2);
+    addDailyDouble(&game, 2);
+    return game;
+}
+
+void addDailyDouble(Game *game, int round)
+{
+    int clueCounts[5] = {0, 0, 0, 0, 0};
+    double odds[5];
+    Clue *clues = NULL;
+    int numClues = 0;
+    if (round == 1)
+    {
+        clues = game->jeopardyClues;
+        numClues = game->numJeopardyClues;
+        double denom = 4300.0;
+        odds[0] = 1.0/denom;
+        odds[1] = 296.0/denom;
+        odds[2] = 1086.0/denom;
+        odds[3] = 1577.0/denom;
+        odds[4] = 1370.0/denom;
+    }
+    else if (round == 2)
+    {
+        clues = game->doubleJeopardyClues;
+        numClues = game->numDoubleJeopardyClues;
+        double denom = 8598.0;
+        odds[0] = 12.0/denom;
+        odds[1] = 777.0/denom;
+        odds[2] = 2438.0/denom;
+        odds[3] = 3303.0/denom;
+        odds[4] = 2068.0/denom;
+    }
+		
+    for (int i = 0; i<numClues; i++)
+    {
+        if (round == 1 || clues[i].column != game->previousDailyDoubleColumn)
+        {
+            clueCounts[clues[i].row]++;
+        }
+    }
+    
+    double weightedOdds[5] = {0, 0, 0, 0, 0};
+    double sumWeightedOdds = 0.0;
+    for (int i = 0; i<5; i++)
+    {
+        weightedOdds[i] = clueCounts[i] * odds[i];
+        sumWeightedOdds += weightedOdds[i];
+    }
+    
+    for (int i = 0; i<5; i++)
+    {
+        weightedOdds[i] /= sumWeightedOdds;
+    }
+    
+    double dailyDoubleRandomizer = drand();
+    double totalOdds = 0.0;
+    
+    
+    
+    int rowToInsertDailyDouble = -1;
+    for (int i = 0; i<5; i++)
+    {
+        totalOdds += weightedOdds[i];
+        if (totalOdds >= dailyDoubleRandomizer)
+        {
+            rowToInsertDailyDouble = i;
+            break;
+        }
+    }
+    
+    for (int i = 0; i<numClues; i++)
+    {
+        Clue *clue = &clues[i];
+        if (clue->row == rowToInsertDailyDouble && !clue->isDailyDouble)
+        {
+            clue->isDailyDouble = 1;
+            return;
+        }
+    }
+}
+
+void shuffleClues(Clue *clues, int numClues)
+{
+    for (int i = numClues; i>0; i--)
+    {
+        Clue lastClue = clues[i-1];
+        int randomIndex = rand()%i;
+        Clue randomClue = clues[randomIndex];
+        clues[i-1] = randomClue;
+        clues[randomIndex] = lastClue;
+    }
+}
+
+int winningScore(Game *game)
+{
+    return MAX(game->players[0].score, MAX(game->players[1].score, game->players[2].score));
+}
+
+int winningPlayerIndex(Game *game)
+{
+	double numWinners = 0;
+	int topScore = winningScore(game);
+	
+	if (topScore <= 0)
+	{
+		return -1;
+	}
+	
+	for (int i = 0; i<3; i++)
+	{
+		if (game->players[i].score == topScore)
+		{
+			numWinners += 1.0;
+		}
+	}
+	
+	double randomIncrement = 1.0/numWinners;
+	double currentValue = 0.0;
+	double randomValue = drand();
+	
+	for (int i = 0; i<3; i++)
+	{
+		if (game->players[i].score == topScore)
+		{
+			currentValue += randomIncrement;
+		}
+		
+		if (currentValue >= randomValue)
+		{
+			return i;
+		}
+	}
+	
+	return -1;
+}
+
+//returns the players index who rang in, or -1 if no one does
+int indexOfPlayerWhoRangInFirst(Game *game, Clue *clue)
+{
+	int attemptsToRingIn[3];
+	double sumBuzzerRatings = 0.0;
+	for (int i = 0; i<3; i++)
+	{
+		// Someone has already answered correctly
+		if (clue->answers[i] == CORRECT_ANSWER)
+		{
+			return -1;
+		}
+		
+		Player *player = &game->players[i];
+		attemptsToRingIn[i] = clue->answers[i] == NO_ANSWER && playerAttemptedToRingIn(player, clue); //only attempt to ring in if you haven't already given an answer
+		if (attemptsToRingIn[i])
+		{
+			sumBuzzerRatings += player->buzzerRating;
+		}
+	}
+	
+	double ringInRandomizer = drand();
+	double oddsOfRingingIn = 0.0;
+	for (int i = 0; i<3; i++)
+	{
+		Player *player = &game->players[i];
+		oddsOfRingingIn += (double)attemptsToRingIn[i] * player->buzzerRating / sumBuzzerRatings;
+		if (oddsOfRingingIn >= ringInRandomizer || (sumBuzzerRatings == 0.0 && attemptsToRingIn[i])) //check to make sure that a lone player with a rating of 0.0 will ring in
+		{
+			return i;
+		}
+	}
+	
+	return -1;
+}
+
+int moneyLeft(Clue *clues, int numClues)
+{
+	int money = 0;
+	for (int i = 0; i<numClues; i++)
+	{
+		money += clues[i].value; 
+	}
+	
+	return money;
+}
+
+void simulateClue(Game *game, Clue *clue)
+{
+	int indexOfPlayerWhoRangIn = indexOfPlayerWhoRangInFirst(game, clue);
+	while (indexOfPlayerWhoRangIn != -1)
+	{
+		Player *player = &game->players[indexOfPlayerWhoRangIn];
+		clue->answers[indexOfPlayerWhoRangIn] = playerAnsweredClue(player, clue);
+		if (clue->answers[indexOfPlayerWhoRangIn] == CORRECT_ANSWER)
+		{
+			player->score += clue->value;
+			game->playerInControlIndex = indexOfPlayerWhoRangIn;
+		} 
+		else
+		{
+			player->score -= clue->value;
+		}
+		indexOfPlayerWhoRangIn = indexOfPlayerWhoRangInFirst(game, clue);
+	}
+}
+
+void simulateDailyDouble(Game *game, Clue *dailyDouble, int moneyLeft)
+{
+  int wager = dailyDoubleWager(game->players, game->playerInControlIndex, moneyLeft);
+	Player *player = &game->players[game->playerInControlIndex];
+	dailyDouble->wagers[game->playerInControlIndex] = wager;
+	dailyDouble->answers[game->playerInControlIndex] = playerAnsweredDailyDouble(player, dailyDouble);
+	if (dailyDouble->answers[game->playerInControlIndex] == CORRECT_ANSWER)
+	{
+		player->score += wager;
+	}
+	else
+	{
+		player->score -= wager;
+	}
+}
+
+void simulateFinalJeopardy(Game *game)
+{
+	for (int i = 0; i<3; i++)
+	{
+		game->finalJeopardyClue.wagers[i] = finalJeopardyWager(game->players, i);
+	}
+	
+	for (int i = 0; i<3; i++)
+	{
+		Player *player = &game->players[i];
+		Clue *finalJeopardyClue = &game->finalJeopardyClue;
+		finalJeopardyClue->answers[i] = playerAnsweredFinalJeopardy(player, finalJeopardyClue);
+		if (finalJeopardyClue->answers[i] == CORRECT_ANSWER)
+		{
+			player->score += finalJeopardyClue->wagers[i];
+		}
+		else
+		{
+			player->score -= finalJeopardyClue->wagers[i];
+		}
+	}
+}
+
+void simulateGame(Game *game)
+{
+	for (int i = 0; i<game->numJeopardyClues; i++)
+	{
+		Clue *clue = &game->jeopardyClues[i];
+		if (clue->isDailyDouble)
+		{
+			int remainingMoney = i + 1 == game->numJeopardyClues ? 36000 : 36000 + moneyLeft(&clue[1], game->numJeopardyClues - i - 1);
+			simulateDailyDouble(game, clue, remainingMoney);
+		}
+		else
+		{
+			simulateClue(game, clue);
+		}
+	}
+
+	//The player in last place starts off in control of the DJ board
+	if (game->numDoubleJeopardyClues == 30)
+	{
+		int minScore = MIN(game->players[0].score, MIN(game->players[1].score, game->players[2].score));
+		int minPlayerIndex = game->players[0].score == minScore ? 0 : game->players[1].score == minScore ? 1: 2;
+		game->playerInControlIndex = minPlayerIndex;
+	}
+
+	for (int i = 0; i<game->numDoubleJeopardyClues; i++)
+	{
+		Clue *clue = &game->doubleJeopardyClues[i];
+		if (clue->isDailyDouble)
+		{
+			int remainingMoney = i + 1 == game->numDoubleJeopardyClues ? 0 : moneyLeft(&clue[1], game->numDoubleJeopardyClues - i - 1);
+			simulateDailyDouble(game, clue, remainingMoney);
+		}
+		else
+		{
+			simulateClue(game, clue);
+		}
+	}
+
+	simulateFinalJeopardy(game);
+}
+
+void simulateGames(Game *game, int trials, int *wins)
+{
+	wins[0] = 0;
+	wins[1] = 0;
+	wins[2] = 0;
+	
+	int scores[3] = {game->players[0].score, game->players[1].score, game->players[2].score};
+	
+	for (int i = 0; i<trials; i++)
+	{
+		gameReset(game, scores);
+		simulateGame(game);
+		int winningIndex = winningPlayerIndex(game);
+		if (winningIndex != -1)
+		{
+			wins[winningIndex] += 1;
+		}
+	}
+}

data/ext/jeopardy/Game.h

@@ -0,0 +1,29 @@
+//Game.h
+#include "Player.h"
+
+#ifndef GAME_H
+#define GAME_H
+
+typedef struct
+{
+	Player players[3];
+	int numJeopardyClues;
+	Clue *jeopardyClues;
+	int numDoubleJeopardyClues;
+	Clue *doubleJeopardyClues;
+	int previousDailyDoubleColumn;
+	Clue finalJeopardyClue;
+	int playerInControlIndex;
+} Game;
+
+Game gameMake(Player *players, int numJeopardyClues, Clue *jeopardyClues, int numDoubleJeopardyClues, Clue *doubleJeopardyClues, Clue finalJeopardyClue, int playerInControlIndex);
+Game averageGame();
+void gameFree(Game game);
+void gameReset(Game *game, int *scores);
+void addDailyDouble(Game *game, int round);
+void simulateGames(Game *game, int trials, int *wins);
+void shuffleClues(Clue *clues, int numClues);
+int winningScore(Game *game);
+int winningPlayerIndex(Game *game);
+
+#endif

data/ext/jeopardy/MinMax.h

@@ -0,0 +1,16 @@
+//
+//  MinMax.h
+//  ArrayTest
+//
+//  Created by Devin Shelly on 4/21/15.
+//  Copyright (c) 2015 Devin Shelly. All rights reserved.
+//
+#ifndef MINMAX_H
+#define MINMAX_H
+
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+
+#define drand() (double)rand()/(double)RAND_MAX
+
+#endif

data/ext/jeopardy/Player.c

@@ -0,0 +1,157 @@
+//Player.c
+#include <stdlib.h>
+#include "math.h"
+#include "MinMax.h"
+#include "Player.h"
+
+Player playerMake(int score, double buzzerRating, double confidenceRating, double knowledgeRating, double ddFJRating)
+{
+	Player player;
+	player.score = score;
+	player.buzzerRating = buzzerRating;
+	player.confidenceRating = confidenceRating;
+	player.knowledgeRating = knowledgeRating;
+	player.ddFJRating = ddFJRating;
+	return player;
+}
+
+Player averagePlayer()
+{
+    return playerMake(0, 1, 0, 0, 0);
+}
+
+double adjustedOdds(double odds, double rating)
+{
+	if (rating > 0.0)
+	{
+		return odds + (1.0-odds) * rating;
+	}
+	return odds + odds*rating;
+}
+
+double oddsPlayerAnsweredClue(Player *player, Clue *clue)
+{
+	double rawOdds = rawOddsOfAnsweringClue(clue);
+	return adjustedOdds(rawOdds, player->knowledgeRating);
+}
+
+ResponseType playerAnsweredClue(Player *player, Clue *clue)
+{
+	return oddsPlayerAnsweredClue(player, clue) >= drand() ? CORRECT_ANSWER : INCORRECT_ANSWER;
+}
+
+double oddsPlayerAnsweredDailyDouble(Player *player, Clue *clue)
+{
+	double rawOdds = rawOddsOfAnsweringDailyDouble(clue);
+	return adjustedOdds(rawOdds, player->ddFJRating);
+}
+
+ResponseType playerAnsweredDailyDouble(Player *player, Clue *clue)
+{
+	return oddsPlayerAnsweredDailyDouble(player, clue) >= drand() ? CORRECT_ANSWER : INCORRECT_ANSWER;
+}
+
+double oddsPlayerAnsweredFinalJeopardy(Player *player, Clue *clue)
+{
+	double rawOdds = rawOddsOfAnsweringFinalJeopardy(clue);
+	return adjustedOdds(rawOdds, player->ddFJRating);
+}
+
+ResponseType playerAnsweredFinalJeopardy(Player *player, Clue *clue)
+{
+	return oddsPlayerAnsweredFinalJeopardy(player, clue) >= drand() ? CORRECT_ANSWER : INCORRECT_ANSWER;
+}
+
+double oddsPlayerAttemptedToRingIn(Player *player, Clue *clue)
+{
+	double rawOdds = rawOddsOfRingingIn(clue);
+	return adjustedOdds(rawOdds, player->confidenceRating);
+}
+
+int playerAttemptedToRingIn(Player *player, Clue *clue)
+{
+	return oddsPlayerAttemptedToRingIn(player, clue) >= drand();
+}
+
+void otherPlayersMinMaxScores(Player *players, int playerIndex, int *minScore, int *maxScore)
+{
+	*maxScore = -INFINITY;
+	*minScore = INFINITY;
+	for (int i = 0; i <3; i++)
+	{
+		if (i != playerIndex)
+		{
+			*maxScore = MAX(*maxScore, players[i].score);
+			*minScore = MIN(*minScore, players[i].score);
+		}
+	}
+}
+
+int dailyDoubleWager(Player *players, int playerInControlIndex, int moneyLeft)
+{
+	int minScore, maxScore;
+	otherPlayersMinMaxScores(players, playerInControlIndex, &minScore, &maxScore);
+	
+	Player player = players[playerInControlIndex];
+	
+	/* Wager the minimum if the game is already a lock even if the player in second gets every remaining question */
+	if ((moneyLeft + maxScore)*2 < player.score && player.score >= 0)
+	{
+		return 5;
+	}
+	
+	/* Wager everything in the first round */
+	if (moneyLeft >= 36000)
+	{	
+		return MAX(1000, player.score);
+	}
+	
+	
+	/* Otherwise, return a random value between 2k and 6k, since that's what your average contestant will do anyways, regardless of the score */
+	return MAX(2000, MIN(2000 + rand()%20*200, players[playerInControlIndex].score));
+}
+
+int finalJeopardyWager(Player *players, int playerIndex)
+{
+	int minScore, maxScore;
+	otherPlayersMinMaxScores(players, playerIndex, &minScore, &maxScore);
+	
+	Player player = players[playerIndex];
+	
+	/* Bet nothing if we have no money to wager */
+	if (player.score <= 0)
+	{
+		return 0;
+	}
+	
+	/* Bet everything but a dollar if we are the only ones playing final jeopardy */
+	if (maxScore <=0)
+	{
+		return player.score-1;
+	}
+	
+	/* First place */
+	if (player.score >= maxScore)
+	{
+		int coverWager = player.score*2 == 3*maxScore ? maxScore*2 - player.score : maxScore*2 - player.score + 1;
+		int safeWager = player.score - maxScore*2 - 1;
+		return MIN(player.score, MAX(coverWager, safeWager));
+	}
+	
+	/* Second place */
+	int firstPlaceIndex = players[0].score == maxScore ? 0 : players[1].score == maxScore ? 1 : 2;
+	int firstWager = finalJeopardyWager(players, firstPlaceIndex);
+	int firstMiss = maxScore - firstWager;
+	if (player.score >= minScore)
+	{
+		int canWin = firstMiss <= 2 * player.score;
+		int coverFirst = canWin && firstMiss > player.score ? player.score : 0;
+		int coverThird = player.score > minScore * 2 ? 0 : canWin ? 2 * minScore - player.score + 1 : 2 * minScore - player.score; /* Go for the outright win if possible, tie for second if not*/
+		return MIN(player.score, MAX(coverFirst, coverThird));
+	}
+	
+	int secondPlaceIndex = 3 - firstPlaceIndex - playerIndex;
+	int secondWager = finalJeopardyWager(players, secondPlaceIndex);
+	int secondMiss = minScore - secondWager;
+	return secondMiss > player.score || firstMiss > player.score ? player.score : 0;
+}

data/ext/jeopardy/Player.h

@@ -0,0 +1,34 @@
+//Player.h
+#include "Clue.h"
+
+#ifndef PLAYER_H
+#define PLAYER_H
+
+typedef struct
+{
+	int score;
+	double buzzerRating;
+	double confidenceRating;
+	double knowledgeRating;
+	double ddFJRating;
+} Player;
+
+Player playerMake(int score, double buzzerRating, double confidenceRating, double knowledgeRating, double ddFJRating);
+Player averagePlayer();
+
+double oddsPlayerAnsweredClue(Player *player, Clue *clue);
+ResponseType playerAnsweredClue(Player *player, Clue *clue);
+
+double oddsPlayerAnsweredDailyDouble(Player *player, Clue *clue);
+ResponseType playerAnsweredDailyDouble(Player *player, Clue *clue);
+
+double oddsPlayerAnsweredFinalJeopardy(Player *player, Clue *clue);
+ResponseType playerAnsweredFinalJeopardy(Player *player, Clue *clue);
+
+double oddsPlayerAttemptedToRingIn(Player *player, Clue *clue);
+int playerAttemptedToRingIn(Player *player, Clue *clue);
+
+int dailyDoubleWager(Player *players, int playerInControl, int moneyLeft);
+int finalJeopardyWager(Player *players, int playerIndex);
+
+#endif

data/ext/jeopardy/extconf.rb

@@ -0,0 +1,9 @@
+# Loads mkmf which is used to make makefiles for Ruby extensions
+require 'mkmf'
+
+# Give it a name
+extension_name = 'jeopardy/jeopardy'
+
+$CFLAGS += " -std=c99"
+
+create_makefile(extension_name)

data/ext/jeopardy/jeopardy.c

@@ -0,0 +1,276 @@
+#include "ruby.h"
+#include "Game.h"
+#include <time.h>
+
+VALUE Jeopardy;
+VALUE rbGame;
+VALUE rbClue;
+VALUE rbPlayer;
+
+static Clue c_clue(VALUE rb_clue)
+{
+	if (rb_obj_is_kind_of(rb_clue, rbClue) == Qfalse)
+	{
+		rb_raise(rb_eTypeError, "Tried to convert a non-Clue Ruby object to a Clue struct.");
+	}
+	Clue clue;
+	clue.value = NUM2INT(rb_funcall(rb_clue, rb_intern("value"), 0));
+	clue.round = NUM2INT(rb_funcall(rb_clue, rb_intern("round"), 0));
+	clue.row = NUM2INT(rb_funcall(rb_clue, rb_intern("row"), 0));
+	clue.column = NUM2INT(rb_funcall(rb_clue, rb_intern("column"), 0));
+	clue.value = NUM2INT(rb_funcall(rb_clue, rb_intern("value"), 0));
+	clue.isDailyDouble = 0;
+	clueReset(&clue);
+	return clue;
+}
+
+static Clue *c_clues(VALUE rb_clues)
+{
+	Check_Type(rb_clues, T_ARRAY);
+	Clue *clues = malloc(sizeof(Clue)*RARRAY_LEN(rb_clues));
+	for (int i = 0; i<RARRAY_LEN(rb_clues); i++)
+	{
+		VALUE iV = INT2NUM(i);
+		VALUE rb_clue = rb_ary_aref(1, &iV, rb_clues);
+		clues[i] = c_clue(rb_clue);
+	}
+	return clues;
+}
+
+static Player c_player(VALUE rb_player)
+{
+	if (rb_obj_is_kind_of(rb_player, rbPlayer) == Qfalse)
+	{
+		rb_raise(rb_eTypeError, "Tried to convert a non-Player Ruby object to a Player struct.");
+	}
+	
+	Player player;
+	player.score = NUM2INT(rb_funcall(rb_player, rb_intern("score"), 0));
+	player.buzzerRating = NUM2DBL(rb_funcall(rb_player, rb_intern("buzzer_rating"), 0));
+	player.confidenceRating = NUM2DBL(rb_funcall(rb_player, rb_intern("confidence_rating"), 0));
+	player.knowledgeRating = NUM2DBL(rb_funcall(rb_player, rb_intern("knowledge_rating"), 0));
+	player.ddFJRating = NUM2DBL(rb_funcall(rb_player, rb_intern("dd_fj_rating"), 0));
+	return player;
+}
+
+static Player *c_players(VALUE rb_players)
+{
+	Check_Type(rb_players, T_ARRAY);
+	if (RARRAY_LEN(rb_players) != 3)
+	{
+		rb_raise(rb_eArgError, "Players array must contain three players.");
+	}
+	
+	Player *players = malloc(sizeof(Player)*3);
+	for (int i = 0; i<3; i++)
+	{
+		VALUE iV = INT2NUM(i);
+		VALUE rb_player = rb_ary_aref(1, &iV, rb_players);
+		players[i] = c_player(rb_player);
+	}
+	return players; 
+}
+
+static Game c_game(VALUE rb_game)
+{
+	Game g;
+	Player *players_pt = c_players(rb_funcall(rb_game, rb_intern("players"), 0));
+	memcpy(g.players, players_pt, sizeof(Player)*3);
+	free(players_pt);
+	
+	VALUE jeopardy_clues = rb_funcall(rb_game, rb_intern("jeopardy_clues"), 0);
+	g.jeopardyClues = c_clues(jeopardy_clues);
+	g.numJeopardyClues = RARRAY_LEN(jeopardy_clues);
+	
+	VALUE double_jeopardy_clues = rb_funcall(rb_game, rb_intern("double_jeopardy_clues"), 0);
+	g.doubleJeopardyClues = c_clues(double_jeopardy_clues);
+	g.numDoubleJeopardyClues = RARRAY_LEN(double_jeopardy_clues);
+	g.finalJeopardyClue = clueMake(0, 3, 0, 0, 0);
+	g.playerInControlIndex = 0;
+	VALUE previous_daily_double_column = rb_funcall(rb_game, rb_intern("previous_daily_double_column"), 0);
+	
+	if (TYPE(previous_daily_double_column) != T_FIXNUM && TYPE(previous_daily_double_column) != T_NIL)
+	{
+		rb_raise(rb_eTypeError, "Previous daily double column must either be a FIXNUM or NIL");
+	}
+	
+	g.previousDailyDoubleColumn = previous_daily_double_column == Qnil ? -1 : NUM2INT(previous_daily_double_column);
+	
+	VALUE jeopardy_daily_doubles_left = rb_funcall(rb_game, rb_intern("jeopardy_daily_doubles_left"), 0);
+	Check_Type(jeopardy_daily_doubles_left, T_FIXNUM);
+	for (int i = 0; i<NUM2INT(jeopardy_daily_doubles_left); i++)
+	{
+		addDailyDouble(&g, 1);
+	}
+	VALUE double_jeopardy_daily_doubles_left = rb_funcall(rb_game, rb_intern("double_jeopardy_daily_doubles_left"), 0);
+	Check_Type(double_jeopardy_daily_doubles_left, T_FIXNUM);
+	for (int i = 0; i<NUM2INT(double_jeopardy_daily_doubles_left); i++)
+	{
+		addDailyDouble(&g, 2);
+	}
+	
+	return g;
+}
+
+static void sync_clue(VALUE rb_clue, Clue c_clue, VALUE rb_players)
+{
+	VALUE rb_answers = rb_hash_new();
+	VALUE rb_wagers = rb_hash_new();
+	rb_funcall(rb_clue, rb_intern("answers="), 1, rb_answers);
+	rb_funcall(rb_clue, rb_intern("wagers="), 1, rb_wagers);
+	
+	for (int j = 0; j<3; j++)
+	{
+		VALUE jV = INT2NUM(j);
+		VALUE rb_player = rb_ary_aref(1, &jV, rb_players);
+		if(c_clue.wagers[j] != NO_WAGER)
+		{
+			rb_hash_aset(rb_wagers, rb_player, INT2NUM(c_clue.wagers[j]));
+		}
+		if (c_clue.answers[j] == CORRECT_ANSWER)
+		{
+			rb_hash_aset(rb_answers, rb_player, Qtrue);
+		}
+		else if (c_clue.answers[j] == INCORRECT_ANSWER)
+		{
+			rb_hash_aset(rb_answers, rb_player, Qfalse);
+		}
+		rb_funcall(rb_clue, rb_intern("round="), 1, INT2NUM(c_clue.round));
+		rb_funcall(rb_clue, rb_intern("row="), 1, INT2NUM(c_clue.row));
+		rb_funcall(rb_clue, rb_intern("column="), 1, INT2NUM(c_clue.column));
+		rb_funcall(rb_clue, rb_intern("value="), 1, INT2NUM(c_clue.value));
+	}
+}
+
+static void sync_player(VALUE rb_player, Player c_player)
+{
+	rb_funcall(rb_player, rb_intern("score="), 1, INT2NUM(c_player.score));
+}
+
+
+static void sync_game(VALUE rb_game, Game c_game)
+{
+	VALUE rb_players = rb_funcall(rb_game, rb_intern("players"), 0);
+	VALUE rb_jeopardy_clues = rb_funcall(rb_game, rb_intern("jeopardy_clues"), 0);
+	for (int i = 0; i<c_game.numJeopardyClues; i++)
+	{
+		VALUE iV = INT2NUM(i);
+		VALUE rb_clue = rb_ary_aref(1, &iV, rb_jeopardy_clues);
+		sync_clue(rb_clue, c_game.jeopardyClues[i], rb_players);
+	}
+	
+	VALUE rb_double_jeopardy_clues = rb_funcall(rb_game, rb_intern("double_jeopardy_clues"), 0);
+	for (int i = 0; i<c_game.numDoubleJeopardyClues; i++)
+	{
+		VALUE iV = INT2NUM(i);
+		VALUE rb_clue = rb_ary_aref(1, &iV, rb_double_jeopardy_clues);
+		sync_clue(rb_clue, c_game.doubleJeopardyClues[i], rb_players);
+	}
+	
+	VALUE rb_final_jeopardy_clue = rb_funcall(rb_game, rb_intern("final_jeopardy_clue"), 0);
+	sync_clue(rb_final_jeopardy_clue, c_game.finalJeopardyClue, rb_players);
+	
+	for (int i = 0; i<3; i++)
+	{
+		VALUE iV = INT2NUM(i);
+		VALUE rb_player = rb_ary_aref(1, &iV, rb_players);
+		sync_player(rb_player, c_game.players[i]);
+	}
+}
+
+static void rb_hash_set_if_nil(VALUE hash, VALUE key, VALUE val)
+{
+	if (rb_hash_aref(hash, key) == Qnil)
+	{
+		rb_hash_aset(hash, key, val);
+	}
+}
+
+static VALUE simulate(int argc, VALUE *argv, VALUE self)
+{
+	VALUE options;
+	rb_scan_args(argc, argv, "01", &options);
+	if (options == Qnil)
+	{
+		options = rb_hash_new();
+	}
+	Check_Type(options, T_HASH);
+	VALUE trials_key = ID2SYM(rb_intern("trials"));
+	VALUE seed_key = ID2SYM(rb_intern("seed"));
+	rb_hash_set_if_nil(options, trials_key, INT2NUM(1));
+	rb_hash_set_if_nil(options, seed_key, INT2NUM(time(NULL)));
+	
+	VALUE trials = rb_hash_aref(options, trials_key);
+	VALUE seed = rb_hash_aref(options, seed_key);
+	
+	Check_Type(trials, T_FIXNUM);
+	Check_Type(seed, T_FIXNUM);
+	if (NUM2INT(trials) < 1)
+	{
+		rb_raise(rb_eArgError, "The number of trials a game is simulated must be greater than zero.");
+	}
+	
+	srand(NUM2INT(seed));
+	srand48(NUM2INT(seed));
+	
+	Game game = c_game(self);
+	
+	int wins[3] = {0, 0, 0};
+	simulateGames(&game, NUM2INT(trials), wins);
+	
+	sync_game(self, game);
+	gameFree(game);
+	VALUE wins_hash = rb_hash_new();
+	VALUE players = rb_funcall(self, rb_intern("players"), 0);
+	
+	for (int i = 0; i<3; i++)
+	{
+		VALUE iV = INT2NUM(i);
+		VALUE player = rb_ary_aref(1, &iV, players);
+		rb_hash_aset(wins_hash, player, INT2NUM(wins[i]));
+	}
+	
+	return wins_hash;
+}
+
+static VALUE daily_double_odds(VALUE self, VALUE rb_clue)
+{
+	Player player = c_player(self);
+	Clue clue = c_clue(rb_clue);
+	clue.isDailyDouble = 1;
+	return DBL2NUM(oddsPlayerAnsweredDailyDouble(&player, &clue));
+}
+
+static VALUE clue_odds(VALUE self, VALUE rb_clue)
+{
+	Player player = c_player(self);
+	Clue clue = c_clue(rb_clue);
+	return DBL2NUM(oddsPlayerAnsweredClue(&player, &clue));
+}
+
+static VALUE final_jeopardy_odds(VALUE self)
+{
+	Player player = c_player(self);
+	Clue finalJeopardy;
+	finalJeopardy.finalJeopardyStandardDeviations = 0.0;
+	return DBL2NUM(oddsPlayerAnsweredFinalJeopardy(&player, &finalJeopardy));
+}
+
+void Init_jeopardy()	
+{
+		
+#if RDOC_CAN_PARSE_DOCUMENTATION
+    Jeopardy = rb_define_module("Jeopardy");
+		rbGame = rb_define_class_under(Jeopardy, "Game", rb_cObject);
+		rbPlayer = rb_define_class_under(Jeopardy, "Player", rb_cObject);
+		rbClue = rb_define_class_under(Jeopardy, "Clue", rb_cObject);
+#endif
+	Jeopardy = rb_const_get(rb_cObject, rb_intern("Jeopardy"));
+	rbGame = rb_const_get(Jeopardy, rb_intern("Game"));
+	rbClue = rb_const_get(Jeopardy, rb_intern("Clue"));
+	rbPlayer = rb_const_get(Jeopardy, rb_intern("Player"));
+	rb_define_method(rbGame, "simulate", simulate, -1);
+	rb_define_method(rbPlayer, "daily_double_odds", daily_double_odds, 1);
+	rb_define_method(rbPlayer, "clue_odds", clue_odds, 1);
+	rb_define_method(rbPlayer, "final_jeopardy_odds", final_jeopardy_odds, 0);
+}

data/lib/jeopardy.rb

@@ -0,0 +1,250 @@
+require 'set'
+
+module Jeopardy
+
+  class Game
+    
+    attr_accessor :jeopardy_clues, :double_jeopardy_clues, :final_jeopardy_clue, :players, :previous_daily_double_column, :jeopardy_daily_doubles_left, :double_jeopardy_daily_doubles_left
+    
+    ##
+    # Initializes a new Jeopardy::Game with an optional hash containing the following keys:
+    #
+    # [:jeopardy_clues] An array containing the Jeopardy::Clue instances remaining in the Jeopardy! round (default: a full round)
+    # [:double_jeopardy_clues]  An array containing the Jeopardy::Clue instances remaining in Double Jeopardy! (default: a full round)
+    # [:players]  An array containing three Jeopardy::Player instances (default: three average players with scores of zero)
+    # [:jeopardy_daily_doubles_left]  The number of Daily Doubles yet to be uncovered in the Jeopardy! round (default : 1)
+    # [:double_jeopardy_daily_doubles_left] The number of Daily Doubles yet to be uncovered in the Double Jeopardy! round (default: 2)
+    # [:previous_daily_double_column] The column that the first DJ Daily Double was found in, eliminating any remaining clues in that column from potentially being the remaining Daily Double (default: nil)
+    
+    def initialize(options = {})
+      options[:jeopardy_clues] ||= 0.upto(29).map { |location| Jeopardy::Clue.new(row: location.to_i%5, column: location.to_i/5, value: location.to_i%5*200+200) }
+      options[:double_jeopardy_clues] ||= 0.upto(29).map { |location| Jeopardy::Clue.new(round: 2, row: location.to_i%5, column: location.to_i/5, value: location.to_i%5*400+400) }
+      options[:players] ||= [Jeopardy::Player.new, Jeopardy::Player.new, Jeopardy::Player.new]
+      options[:jeopardy_daily_doubles_left] ||= 1
+      options[:double_jeopardy_daily_doubles_left] ||= 2
+      
+      @jeopardy_clues = options[:jeopardy_clues]
+      @double_jeopardy_clues = options[:double_jeopardy_clues]
+      @final_jeopardy_clue = Jeopardy::Clue.new(round: 3, value: 0)
+      @players = options[:players]
+      @previous_daily_double_column = options[:previous_daily_double_column]
+      @jeopardy_daily_doubles_left = options[:jeopardy_daily_doubles_left]
+      @double_jeopardy_daily_doubles_left = options[:double_jeopardy_daily_doubles_left]
+    end
+    
+    ##
+    # Simulates a Jeopardy::Game with an options hash containing the following keys:
+    #
+    # [:trials] The number of times the Monte Carlo sim will be run (default: 1)
+    # [:seed] The seed which is fed to the random number generators, or nil for a time based seed (default: nil)
+    #
+    # Returns a hash with Jeopardy::Game#players as keys and their respective wins
+    # as values.
+    #
+    # *Usage*
+    #
+    # [<tt>Jeopardy::Game.new.simulate(seed: 0)</tt>] #=>	<tt>{ Jeopardy::Game.players[0] => 0, Jeopardy::Game.players[1] => 0, Jeopardy::Game.players[2] => 1 }</tt>
+    # [<tt>Jeopardy::Game.new.simulate(seed: 0, trials: 1000)</tt>] #=>	<tt>{ Jeopardy::Game.players[0] => 338, Jeopardy::Game.players[1] => 343,	Jeopardy::Game.players[2] => 319 }</tt>
+    
+    def simulate(options = {})
+      #empty, just used a placeholder for documentation
+      #actual implementation is in jeopardy.c
+    end
+    
+    ##
+    # Resets the games scores to the values found in the given array. Returns self so that a simulate call may be chained
+    #
+    # [:scores] Three scores corresponding to the new score for each player (default: [0, 0, 0])
+    #
+    # *Usage*
+    #
+    # [<tt>g = Jeopardy::Game.new</tt>]
+    # [<tt>g.simulate</tt>]
+    # [<tt>g.reset_scores([0, 0, 0])</tt>] #=>  <tt>g</tt>
+    
+    def reset_scores(scores = [0, 0, 0])
+      @players.each_with_index {|player, index| player.score = scores[index]}
+      return self
+    end
+    
+    ##
+    # Returns an array containing the Daily Doubles with the following parameter:
+    #
+    # [:rounds] An array or integer declaring which round(s) to look for Daily Doubles in (default: [1,2])
+    # 
+    # Note: Daily Doubles are not determined until after a call to Jeopardy::Game#simulate.
+    #
+    # *Usage*
+    #
+    # [<tt>g = Jeopardy::Game.new</tt>]
+    # [<tt>g.simulate(seed: 0)</tt>]
+    # [<tt>g.daily_doubles([1,2])</tt>] #=>  <tt>[<Jeopardy::Clue (@round = 1)>, <Jeopardy::Clue (@round = 2)>, <Jeopardy::Clue (@round = 2)>]</tt>
+    # [<tt>g.daily_doubles(1)</tt>] #=>  <tt>[<Jeopardy::Clue (@round = 1)>]</tt>
+    
+    def daily_doubles(rounds = [1, 2])
+      rounds = Set.new([rounds].flatten)
+      all_clues = @jeopardy_clues + @double_jeopardy_clues
+      all_clues.select {|clue| clue.wagers.count > 0 && rounds.include?(clue.round)}
+    end
+    
+    ##
+    # Returns a hash containing the Jeopardy::Game#players as keys and the corresponding Coryat scores as values.
+    #
+    # Note: Coryat scores cannot be calculated prior to a call to Jeopardy::Game#simulate
+    #
+    # *Usage*
+    #
+    # [<tt>g = Jeopardy::Game.new</tt>]
+    # [<tt>g.simulate</tt>]
+    # [<tt>g.coryats</tt>] #=> <tt>{ g.players[0] => 14_400, g.players[1] => 15_800, g.players[2] => 14_000 }</tt>
+    
+    def coryats
+      coryats = {}
+      players.each {|player| coryats[player] = 0}
+      
+      (@jeopardy_clues + @double_jeopardy_clues).each do |clue|
+        clue.answers.each do |player, answer|
+          coryats[player] += clue.value if answer
+          coryats[player] -= clue.value if !answer && clue.wagers.count == 0
+        end
+      end
+      return coryats
+    end
+    
+    ##
+    # Returns a hash containing the Jeopardy::Game#players as keys and their corresponding scores as values, with the following optional parameter:
+    #
+    # rounds: An array or integer declaring which round(s) to calculate scores for (default: [1,2,3])
+    #
+    # Note: Scores cannot be determined until after a call to Jeopardy::Game#simulate. If the simulation starts in the middle of a round, this will not
+    # coincide with the scores found in Jeopardy::Game#players, as those scores include the beginning value. These scores only show the results of the clues
+    # simulated.
+    #
+    # *Usage*
+    #
+    # [<tt>g = Jeopardy::Game.new</tt>]
+    # [<tt>g.simulate(seed: 0)</tt>]
+    # [<tt>g.scores(1)</tt>] #=> <tt>{ g.players[0] => 5_200, g.players[2] => 4_600, g.players[3] => 7_400 }</tt>
+    # [<tt>g.scores(2)</tt>] #=> <tt>{ g.players[0] => 9_200, g.players[2] => 6_000, g.players[3] => 7_600 }</tt>
+    # [<tt>g.scores( [1,2])</tt>]  #=> <tt>{ g.players[0] => 14_400, g.players[2] => 10_600, g.players[3] => 15_000 }</tt>
+    # [<tt>g.scores(3)</tt>]  #=> <tt>{ g.players[0] => 6801, g.players[2] => 0, g.players[3] => 13_801 }</tt>
+    # [<tt>g.scores([1,2,3])</tt>]  #=> <tt>{ g.players[0] => 21_201, g.players[1] => 10_600, g.players[2] => 28_801 }</tt>
+    
+    def scores(rounds=[1,2,3])
+      rounds = Set.new([rounds].flatten)
+      all_clues = @jeopardy_clues + @double_jeopardy_clues + [@final_jeopardy_clue]
+      clues_for_rounds = all_clues.select {|clue| rounds.include?(clue.round)}
+      scores = {}
+      players.each {|player| scores[player] = 0}
+      clues_for_rounds.each do |clue|
+        clue.answers.each do |player, answer|
+          wager = clue.wagers[player]
+          scores[player] += wager if !wager.nil? && answer
+          scores[player] -= wager if !wager.nil? && !answer
+          scores[player] += clue.value if wager.nil? && answer
+          scores[player] -= clue.value if wager.nil? && !answer
+        end
+      end
+      return scores
+    end
+    
+  end
+
+  class Player
+
+    attr_accessor :score, :buzzer_rating, :knowledge_rating, :dd_fj_rating, :confidence_rating
+
+    ##
+    # Initializes a new Jeopardy::Game with an optional hash containing the following keys:
+    #
+    # [:score] The current score of the player.
+    # [:buzzer_rating] A rating from zero to infinity of how likely a player is to ring in first. When multiple players ring in, the odds of an individual player ringing in first is equal to their rating divided by the sum of the ratings. (default: 1.0)
+    # [:knowledge_rating] A rating from -1.0 to 1.0 of how likely a player is to answer correctly after ringing in. It's a piecewise function with -1.0 ratings always answering incorrectly, 0.0 answering at the Jeopardy! average, and 1.0 always answering correctly. (default: 0.0)
+    # [:dd_fj_knowledge] The same as knowledge_rating, but pertaining to Daily Doubles/Final Jeopardy! instead of after ringing in. (default: 0.0)
+    # [:confidence_rating] How often a player attempts to ring in. -1.0 will never ring in, 0.0 rings in at an average rate, and 1.0 rings in every clue. (default: 0.0)
+    
+    def initialize(options = {})
+      options[:score] ||= 0
+      options[:buzzer_rating] ||= 1.0
+      options[:knowledge_rating] ||= 0.0
+      options[:dd_fj_rating] ||= 0.0
+      options[:confidence_rating] ||= 0.0
+
+      @score = options[:score].to_i
+      @buzzer_rating = options[:buzzer_rating].to_f
+      @knowledge_rating = options[:knowledge_rating].to_f
+      @dd_fj_rating = options[:dd_fj_rating].to_f
+      @confidence_rating = options[:confidence_rating].to_f
+    end
+    
+    ##
+    # Returns the decimal odds of the Player answering a Daily Double correctly.
+    #
+    # *Usage*
+    #
+    # [<tt>Jeopardy::Player.new.odds_of_answering_daily_double(Jeopardy::Clue.new)</tt>] #=>	0.76
+    #
+    
+    def daily_double_odds(daily_double)
+      #empty, just used a placeholder for documentation
+      #actual implementation is in jeopardy.c
+    end 
+
+    ##
+    # Return the decimal odds of the Player answering an ordinary clue correctly.
+    #
+    # *Usage*
+    #
+    # [<tt>Jeopardy::Player.new.odds_of_answering_clue(Jeopardy::Clue.new)</tt>] #=>	0.9316826244
+    #
+    
+    def clue_odds(clue)
+      #empty, just used a placeholder for documentation
+      #actual implementation is in jeopardy.c
+    end
+    
+    ##
+    # Return the decimal odds of the Player answering final jeopardy correctly.
+    #
+    # *Usage*
+    #
+    # [<tt>Jeopardy::Player.new.final_jeopardy_odds(Jeopardy::Clue.new)</tt>] #=>	0.9316826244
+    #
+    def final_jeopardy_odds()
+      #empty, just used a placeholder for documentation
+      #actual implementation is in jeopardy.c
+    end
+  end
+
+  class Clue
+
+    attr_accessor :round, :row, :column, :value, :answers, :wagers
+    
+    ##
+    # Initializes a new Jeopardy::Game with an optional hash containing the following keys:
+    #
+    # [:round]  An integer corresponding to the round the clue is in. 1 is Jeopardy!, 2 is Double Jeopardy!, 3 is Final Jeopardy! (default: 1)
+    # [:row]  The row on the game board the clue is found. Zero is the topmost row, four the bottom row. Meaningless for a FJ! clue. (default: 0)
+    # [:column] The column on the game board. Zero is the leftmost column, five the rightmost. Again, meaningless for a FJ! clue. (default: 0)
+    # [:answers]  A hash containing each player who answered as the key and true/false for a correct/incorrect answer. (default: {})
+    # [:wagers] A hash containing each player who wagered as the key and their wager as the value. Should be empty except for Daily Doubles/FJ. (default: {})
+    
+    def initialize(options = {})
+      options[:round] ||= 1
+      options[:row] ||= 0
+      options[:column] ||= 0
+      options[:wagers] ||= {}
+      options[:answers] ||= {}
+      
+      @round = options[:round]
+      @row = options[:row]
+      @column = options[:column]
+      @value = (options[:row]*200 + 200) * options[:round] if options[:round] == 1 || options[:round] == 2
+      @value = 0 if @value.nil?
+      @answers = options[:answers]
+      @wagers = options[:wagers]
+    end
+  end
+end
+
+require_relative "jeopardy/jeopardy"

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: jeopardy
+version: !ruby/object:Gem::Version
+  version: 0.0.26
+platform: ruby
+authors:
+- Devin Shelly
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-29 00:00:00.000000000 Z
+dependencies: []
+description: A fast Monte Carlo simulation of the television game show Jeopardy!
+email: devin@devinshelly.com
+executables: []
+extensions:
+- ext/jeopardy/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/jeopardy/Clue.c
+- ext/jeopardy/Clue.h
+- ext/jeopardy/Game.c
+- ext/jeopardy/Game.h
+- ext/jeopardy/MinMax.h
+- ext/jeopardy/Player.c
+- ext/jeopardy/Player.h
+- ext/jeopardy/extconf.rb
+- ext/jeopardy/jeopardy.c
+- lib/jeopardy.rb
+homepage: http://rubygems.org/gems/jeopardy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Jeopardy Game Simulator
+test_files: []
+has_rdoc: