Code Battle - Sutda Game

Game Rules

Check the rules of the game, fill in the functions below, select your opponent and press the start button to start the game.

You and your opponent will each receive 2 cards (Hwatu card), and it is a game where you win or lose with a combination of 2 cards.

There are 20 cards in total, and there are two pairs of cards that represent the numbers 1 to 10. It is assumed that the cards consist of numbers 1 to 10 and numbers 11 to 20 so that only the numbers can be distinguished. For example, 15 is the second card meaning 5.

You get money when the game starts, you get 2 cards and 1 opponent card at the start of the round, and you have to choose raise or call or die on each turn.

"raise" is an action that raises table money, "call" is an action that accepts only the amount of money raised by the opponent and ends the round and confirms the win or lose, and "die" is an action that gives up the opponent's card check and pays only the basic money(1) before giving up the round.

My Code (JavaScript)

/** * Please write code with JAVASCRIPT. */ var who_first = ""; var my_money = 0; // My money. Betting more than you have is a forfeit. /** * Called when the game starts. * Here is the initialization of the variables to use during the game. * @param data * data.my_money: My starting money * data.op_money: The opponent's starting money */ function onGameStart(data) { // print(string) is a function that outputs text to the game log area at the bottom of the play area. print("onGameStart!"); } /** * Called when the round starts. * One round means one sutda match, and here you will receive the data for the match. * @param data * data.my_money: My money * data.op_money: The opponent's money * data.my_cards: My card numbers [First card, Second card] * data.op_card: The opponent's first card number * data.who_first: Who is the first turn. "me" means me, "op" means the opponent. */ function onRoundStart(data) { print( "onRoundStart!" +" my_money:"+data.my_money+", op_money:"+data.op_money +", my_cards:["+data.my_cards[0]+","+data.my_cards[1]+"]" +", op_card:"+data.op_card+", who_first:"+data.who_first ); who_first = data.who_first; my_money = data.my_money; } /** * Called when the turn starts. * You need to choose "raise" or "call" or "die" in here. * @param data * data.my_cards: My card numbers [First card, Second card] * data.op_card: The opponent's first card number * data.op_turn_result: The result of the opponent's turn. The return value of the opponent's onTurnStart(). * @return { * "action": "raise" or "call" or "die". You must return "raise" or "die" when the "data.op_turn_result" is null.(the first turn). * "money": If you choose "raise", this value should be the sum of the opponent's raising money and my raising money. * If you choose "call", this value should be the opponent's raising money. * If you choose "die", this value should be 1. * } */ function onTurnStart(data) { // A very simple sample code is below // Write a better algorithm to determine "action" and "money". var result = {}; if (who_first == "me" && data.op_turn_result == null) { // Betting your last coin leaves nothing for the next turn, which is a // forfeit: even "die" costs 1. So keep one coin back. if (my_money >= 2) { result["action"] = "raise"; result["money"] = 1; } else { result["action"] = "die"; result["money"] = 1; } } else if (data.op_turn_result.money > my_money) { // You cannot bet more than you have. Calling here would be a forfeit. result["action"] = "die"; result["money"] = 1; } else { // who_first == "op" result["action"] = "call"; result["money"] = data.op_turn_result.money; } // Subtract what this turn costs. my_money only arrives at the start of a // round, so without this it stays higher than what you actually hold. my_money -= result["money"]; // Print logs var op_turn_str; if (data.op_turn_result == null) { op_turn_str = "op_turn{ null }"; } else { op_turn_str = "op_turn{ action:"+data.op_turn_result.action+", money:"+data.op_turn_result.money+" }"; } print("onTurnStart! "+op_turn_str+", my_return: { action:"+result.action+", money:"+result.money+" }"); return result; } /** * It is called when the round is over and receives the result of the round. * If you or your opponent's turn result is not raise (call or die), the round ends and somebody makes money. * @param data * data.win: -1(lose) or 1(win) * data.last_turn_result: The last turn result of the round * data.who_last: Whose turn was the last turn. me or op * data.my_money: My current own money * data.op_money: The opponent's current own money * data.my_cards: My card numbers [First card, Second card] * data.op_cards: The opponent's card numbers [First card, Second card(If you or your opponent's last action is "die", this value is 0)] */ function onRoundEnd(data) { print( "onRoundEnd! win:"+data.win +", last_turn { action:"+data.last_turn_result.action+", money:"+data.last_turn_result.money+", who:"+data.who_last+" }" +", my_money:"+data.my_money+", op_money:"+data.op_money +", my_cards:["+data.my_cards[0]+","+data.my_cards[1]+"]" +", op_cards:["+data.op_cards[0]+","+data.op_cards[1]+"]" ); } /** * It is called when the game is over and receives the result of the game. * @param data * data.win: -1(lose) or 0(tie) or 1(win) * data.my_money: My final money * data.op_money: The opponent's final money */ function onGameEnd(data) { print("onGameEnd! win:"+data.win+", my_money:"+data.my_money+", op_money:"+data.op_money); print("----------------------------"); }

Opponents

If you or the opponent's screen is not visible, the communication speed will be slower.

TURN

ROUND

GAME

WIN

LOSE

Recent logs are displayed at the top.

When to fold and when to call

In Sutda you cannot choose your hand. The cards come at random, and all you decide is whether to bet, call, or fold. That narrows strategy down to one question: when do you fold? And folding costs 1 too. Below are three ways to fold and the score each one actually produced.

1. Call whatever is on the table (the default sample)

This is what the default code on this page does. It bets 1 when it goes first, and otherwise calls exactly what the opponent bet. It never looks at its own hand. The rank table for all 20 cards sits further down this page and this code never uses it.

LEVEL 1 roughly even LEVEL 2·3 mostly loses

Against LEVEL 1 it is even, because that opponent also bets only 1 and never folds, so a round moves just 1 either way. But LEVEL 2 and LEVEL 3 raise hard when they hold a strong hand. Calling without looking at your hand keeps feeding those big bets.

2. Fold when the hand is weak

Score the two cards and fold below 5-kkut. That throws away about half of all hands. The scoring rule is copied straight from the rank table further down this page.

var my_money = 0;

function onGameStart() {}

function onRoundStart(data) {
	// my_money arrives only when a round starts. Track it yourself within a round.
	my_money = data.my_money;
}

// The score of two cards, copied from the rank table below.
// The kkut tiebreak rule is left out to keep it short.
function getPoint(c1, c2) {
	var n1 = c1 > 10 ? c1 - 10 : c1;
	var n2 = c2 > 10 ? c2 - 10 : c2;

	if ((c1 === 3 && c2 === 8) || (c1 === 8 && c2 === 3)) { return 30000; }
	if ((c1 === 1 && c2 === 8) || (c1 === 8 && c2 === 1)) { return 20000; }
	if ((c1 === 1 && c2 === 3) || (c1 === 3 && c2 === 1)) { return 10000; }
	if (n1 === n2) { return n1 * 1000; }
	return ((c1 + c2) % 10) * 100;
}

function onTurnStart(data) {
	var point = getPoint(data.my_cards[0], data.my_cards[1]);
	var bet = data.op_turn_result;
	var result;

	if (point < 500) {
		// Fold below 5-kkut. That throws away about half of all hands.
		result = {action: "die", money: 1};
	} else if (bet === null) {
		result = my_money >= 2
			? {action: "raise", money: 1}
			: {action: "die", money: 1};
	} else if (bet.money > my_money) {
		result = {action: "die", money: 1};
	} else {
		result = {action: "call", money: bet.money};
	}
	my_money -= result.money;
	return result;
}

function onRoundEnd() {}
function onGameEnd() {}

LEVEL 1 loses every game LEVEL 2 has the edge LEVEL 3 roughly even

LEVEL 2 and LEVEL 3 flip. Dropping weak hands when they raise hard removes the big losses. And yet it loses every game to the simplest opponent, LEVEL 1 — the only one of the three that computes neither odds nor bet sizes. This is the strangest point in the game.

3. Count the fact that folding also costs 1

LEVEL 1 bets only 1 and never folds. Calling that 1 costs 1, and folding costs 1. They are the same. Folding saves nothing and only throws away a chance to win, so if there is any chance at all, calling is better. The rule for what counts as a weak hand stays exactly as it was in 2. Only one condition goes in front of it.

op_turn_result.money == 1 Fold costs 1, call costs 1. Same, so call.

op_turn_result.money == 20 Fold costs 1, call costs 20. Different, so drop the weak hand.

var my_money = 0;

function onGameStart() {}

function onRoundStart(data) {
	// my_money arrives only when a round starts. Track it yourself within a round.
	my_money = data.my_money;
}

// The score of two cards, copied from the rank table below.
// The kkut tiebreak rule is left out to keep it short.
function getPoint(c1, c2) {
	var n1 = c1 > 10 ? c1 - 10 : c1;
	var n2 = c2 > 10 ? c2 - 10 : c2;

	if ((c1 === 3 && c2 === 8) || (c1 === 8 && c2 === 3)) { return 30000; }
	if ((c1 === 1 && c2 === 8) || (c1 === 8 && c2 === 1)) { return 20000; }
	if ((c1 === 1 && c2 === 3) || (c1 === 3 && c2 === 1)) { return 10000; }
	if (n1 === n2) { return n1 * 1000; }
	return ((c1 + c2) % 10) * 100;
}

function onTurnStart(data) {
	var point = getPoint(data.my_cards[0], data.my_cards[1]);
	var bet = data.op_turn_result;
	var result;

	if (bet === null) {
		// I am first. Folding costs 1 and betting costs 1, so even a weak hand bets.
		result = my_money >= 2
			? {action: "raise", money: 1}
			: {action: "die", money: 1};
	} else if (bet.money > my_money) {
		// You cannot pay more money than you have.
		result = {action: "die", money: 1};
	} else if (bet.money <= 1) {
		// Calling costs what folding costs. Folding saves nothing here, so call.
		result = {action: "call", money: bet.money};
	} else if (point >= 500) {
		result = {action: "call", money: bet.money};
	} else {
		// The bet now costs more than folding. Only from here do I drop weak hands.
		result = {action: "die", money: 1};
	}
	my_money -= result.money;
	return result;
}

function onRoundEnd() {}
function onGameEnd() {}

LEVEL 1 roughly even LEVEL 2 has the edge LEVEL 3 roughly even

LEVEL 1 comes back from a total loss to even, and the LEVEL 2 and LEVEL 3 scores stay where they were. The weak-hand line is still 5-kkut. The only change is that folding is now compared against what is on the table. Folding is not free, and it does not always cost the same either.

4. Your turn from here

The three above leave two things untouched. One is the opponent's first card: onTurnStart hands you data.op_card, so one of their cards is visible. Count which of the remaining cards would beat your hand and you have your odds — that is what LEVEL 2 does. The other is the amount. All three above always bet 1. Betting big on a strong hand earns more, and betting big on a weak one can make the opponent fold — but if they don't, you lose that much more. Paste the code above into the editor and start changing it here.

How a battle runs

Code battle is a battle between your code and opponent's code, and the language is JAVASCRIPT.
Fill in the code, select the opponent (LEVEL1, LEVEL2, LEVEL3, Online opponent) and then press the game start button will start the match.
1 game consists of a maximum of 200 rounds and the game ends if either you or your opponent runs out of money while the round is repeated. And, 1 round consists of several turns. On each turn, you can "raise" to raise table money and pass it to your opponent's turn, or you can "call" or "die" to finish the round.
OnGameStart and onGameEnd functions are called at the beginning and end of the game, onRoundStart and onRoundEnd functions are called at the beginning and end of each round, and onTurnStart is called on each turn. onGameStart => onRoundStart => onTurnStart => onRoundEnd => onGameEnd. You can implement your own logic in each function.

Order	Group	Name	Remarks
1	Gwang-ttaeng	3 and 8 gwang-ttaeng	When two cards are 3 and 8. Sutda's strongest combination.
2	Gwang-ttaeng	1 and 8 gwang-ttaeng	When two cards are 1 and 8.
3	Gwang-ttaeng	1 and 3 gwang-ttaeng	When two cards are 1 and 3.
4	Ttaeng	10 ttaeng	When two cards are 10 and 20.
5	Ttaeng	9 ttaeng	When two cards are 9 and 19.
6	Ttaeng	8 ttaeng	When two cards are 8 and 18.
7	Ttaeng	7 ttaeng	When two cards are 7 and 17.
8	Ttaeng	6 ttaeng	When two cards are 6 and 16.
9	Ttaeng	5 ttaeng	When two cards are 5 and 15.
10	Ttaeng	4 ttaeng	When two cards are 4 and 14.
11	Ttaeng	3 ttaeng	When two cards are 3 and 13.
12	Ttaeng	2 ttaeng	When two cards are 2 and 12.
13	Ttaeng	1 ttaeng	When two cards are 1 and 11.
14	Kkeus	9 kkeus	When the "units" number of the sum of two card is 9. (Ex: 5 and 14, or 3 and 6). If it's the same, compare the big cards. (Ex: ['5' and 4] < [3 and '6'])
15	Kkeus	8 kkeus	When the "units" number of the sum of two card is 8. (Ex: 5 and 13, or 6 and 2)
16	Kkeus	7 kkeus	When the "units" number of the sum of two card is 7. (Ex: 2 and 15, or 3 and 4)
17	Kkeus	6 kkeus	When the "units" number of the sum of two card is 6. (Ex: 5 and 11, or 1 and 5)
18	Kkeus	5 kkeus	When the "units" number of the sum of two card is 5. (Ex: 2 and 13, or 3 and 2)
19	Kkeus	4 kkeus	When the "units" number of the sum of two card is 4. (Ex: 4 and 10, or 1 and 3)
20	Kkeus	3 kkeus	When the "units" number of the sum of two card is 3. (Ex: 1 and 12, or 2 and 1)
21	Kkeus	2 kkeus	When the "units" number of the sum of two card is 2. (Ex: 2 and 10, or 3 and 9)
22	Kkeus	1 kkeus	When the "units" number of the sum of two card is 1. (Ex: 1 and 10, or 5 and 6)
23	Kkeus	0 kkeus	When the "units" number of the sum of two card is 0. (Ex: 1 and 9, or 3 and 7)

Sutda has five hooks and no onTurnEnd. onTurnStart must return an object with action and money, where action is one of raise, call, or die. You cannot call on the first turn. The code in 2 and 3 above contains all five hooks, so it runs as-is when pasted in.

Also, my_money arrives only when a round starts. You have to subtract what you bet within a round yourself, or you will bet more than you hold and be disqualified. Folding costs 1 too, so if you bet down to your last coin you cannot even fold on the next turn. Disqualification looks like an ordinary loss on screen, which makes it hard to find.

Scores were measured over 150 games per opponent, and a test in the repository re-checks them against the real rule engine every time. One game runs up to 200 rounds. Here "loses every game" means a win rate of 3% or below, "mostly loses" 15% or below, "roughly even" 20-80%, and "has the edge" 50% or above. While measuring with 60 games, the LEVEL 2 win rate of method 3 moved between 53% and 67%; since the line for the edge is 50%, the count went up to 150.