Return Styles: Pseud0ch, Terminal, Valhalla, NES, Geocities, Blue Moon. Entire thread

AI tournament

Name: Anonymous 2015-06-25 5:53

I propose we have an AI tournament. Decide on a game and a way to run the bots. We could agree on a language or if that is not possible, write a text protocol for the bot to use to communicate with the game server.

Name: Anonymous 2015-06-25 8:09

Go playing bots written in Go.

Name: Anonymous 2015-06-25 13:59

>>2
I don't want to learn Go, but a Go tournament would be a fun challenge.

Name: Anonymous 2015-06-25 19:39

>>2
Go is too hard. Pick something easier. Like weighted rock paper scissors or something. Or a simple fighting game with punches and blocks.

Name: Anonymous 2015-06-25 19:54

how about gomoku?

Name: Anonymous 2015-06-25 20:28

>>5
I hadn't heard of it before but sure, it looks like a good choice. It should be a game where you can write a novice bot in 15 minutes, to make it easier to participate for time constrained people.
https://en.wikipedia.org/wiki/Gomoku

Name: Anonymous 2015-06-25 21:15

Why don't we host a /prog/ Robocode challenge?

http://robocode.sourceforge.net/

It seems that this software was built for this kind of fun challenge in mind.

Unfortunately, all bots written for it must be written in Java, but I still think that it would be a fun challenge.

Name: Anonymous 2015-06-25 21:55

>>7
No java. I'm writing an arbitrary dimensional multiplayer gomoku in chibi-scheme right now. I'll be done soon.

Name: Anonymous 2015-06-25 23:53

Ok, here's a game. You can write bots in scheme.

#!/usr/bin/env chibi-scheme

(import (scheme base) (scheme write) (scheme read) (scheme r5rs))

;; A lazy list would be better
(define (count-chain-length start-point offset-function still-chain?)
(let loop ((point start-point) (count 0))
(if (not (still-chain? point))
count
(loop (offset-function point) (+ count 1)))))

(define (point-sum point1 point2)
(map + point1 point2))

(define (point-sub point1 point2)
(map - point1 point2))

(define (point-on-board? point board-corner)
(if (not (= (length point) (length board-corner)))
(error "Inconsistent dimensions" point board-corner))
(let loop ((point point) (board-corner board-corner))
(if (null? point)
#t
(and (<= 0 (car point) (- (car board-corner) 1))
(loop (cdr point) (cdr board-corner))))))

(define (point->index point board-corner)
(if (not (= (length point) (length board-corner)))
(error "Inconsistent dimensions" point board-corner))
(let loop ((point point) (board-corner board-corner) (acc 0))
(if (null? point)
acc
(loop (cdr point)
(cdr board-corner)
(+ (car point) (* acc (car board-corner)))))))

(define (board-corner->length board-corner)
(apply * board-corner))

(define (make-board board-corner blank)
(make-vector (board-corner->length board-corner) blank))

(define (board-ref board board-corner point)
(if (not (point-on-board? point board-corner))
(error "Index out of range" point board-corner))
(vector-ref board (point->index point board-corner)))

(define (board-set! board board-corner point value)
(if (not (point-on-board? point board-corner))
(error "Index out of range" point board-corner))
(vector-set! board (point->index point board-corner) value))

(define (player-still-chain? board board-corner player)
(lambda (point)
(and (point-on-board? point board-corner)
(eq? player (board-ref board board-corner point)))))

;; Fix the append to make it efficient.
(define (all-bit-strings len)
(if (= len 1)
'((0) (1))
(let ((lower (all-bit-strings (- len 1))))
(append (map (lambda (bit-str) (cons 0 bit-str)) lower)
(map (lambda (bit-str) (cons 1 bit-str)) lower)))))

;; All directions are all non-zero bit strings.
;; all-bit-strings has the zero bit string at the front,
;; so just cdr it.
(define (all-directions dimension)
(cdr (all-bit-strings dimension)))

(define (find-max-length-of-move point still-chain? all-directions)
(apply max
(map (lambda (direction)
(+ (count-chain-length point
(lambda (p)
(point-sum p direction))
still-chain?) ;; count length going forwards
(count-chain-length point
(lambda (p)
(point-sub p direction))
still-chain?) ;; count length going backwards
-1)) ;; center point is counted twice.
all-directions)))

;; player -- (player-sym move-function state)

;; move-function -- lambda (board-corner-copy win-length board-read player-syms-copy blank player-sym turn-number actual-moves state) -> move-point

(define (copy-list lis) (map (lambda (x) x) lis))

(define (play-game board-corner win-length blank players)
(let* ((max-moves (board-corner->length board-corner))
(board (make-board board-corner blank))
(board-read (lambda (point) (board-ref board board-corner point)))
(player-syms (map car players))
(all-dirs (all-directions (length board-corner))))
(let loop ((players-pos players)
(turn-number 1)
(actual-moves 0)
(move-history '()))
(if (>= actual-moves max-moves)
`(tie (board-corner ,board-corner)
(board ,board)
(turn-number ,turn-number)
(actual-moves ,actual-moves)
(move-history ,move-history))
(let* ((player (car players-pos))
(player-sym (car player))
(move-function (cadr player))
(player-state (caddr player))
(next-players-pos (if (null? (cdr players-pos))
players
(cdr players-pos)))
(player-move (move-function (copy-list board-corner)
win-length
board-read
(copy-list player-syms)
blank
player-sym
turn-number
actual-moves
player-state)))
(if (or (not (list? player-move))
(not (= (length player-move) (length board-corner)))
(not (point-on-board? player-move board-corner))
(not (eq? blank (board-read player-move)))) ;; Invalid move, player forfeits turn.
(loop next-players-pos
(+ turn-number 1)
actual-moves
(cons `(,turn-number ,player-sym ,player-move invalid-move)
move-history)))
(begin
(board-set! board board-corner player-move player-sym)
(let* ((still-chain? (player-still-chain? board board-corner player-sym))
(move-score (find-max-length-of-move player-move still-chain? all-dirs)))
(if (>= move-score win-length) ;; player wins
`(win (winner ,player-sym)
(board-corner ,board-corner)
(board ,board)
(turn-number ,turn-number)
(actual-moves ,actual-moves)
(move-history ,(cons `(,turn-number ,player-sym ,player-move win ,move-score)
move-history)))
(loop next-players-pos
(+ turn-number 1)
(+ actual-moves 1)
(cons `(,turn-number ,player-sym ,player-move success ,move-score)
move-history))))))))))


(define (display-board board-read board-corner)
(case (length board-corner)
((1) (let display-loop ((index 0))
(when (< index (car board-corner))
(display (board-read (list index)))
(display #\space)
(display-loop (+ index 1))))
(newline))
((2) (let display-row ((row 0))
(when (< row (cadr board-corner))
(let display-row-col ((column 0))
(when (< column (car board-corner))
(display (board-read (list column row)))
(display #\space)
(display-row-col (+ column 1))))
(newline)
(display-row (+ row 1)))))
(else (display "Don't know how..."))))

(define (human-move board-corner win-length board-read player-syms blank player-sym turn-number actual-moves state)
;; display board
(display `(state ,state)) (newline)
(display-board board-read board-corner)
(display (string-append (symbol->string player-sym) "-kun's turn. Make your move."))
(newline)
(read))

(display (play-game '(15 15) 5 '- `((a ,human-move ,(vector 1 2 3)) (b ,human-move ,(vector 2 3 4)))))

Name: Anonymous 2015-06-26 0:45

Why don't you just run a dedicated server in any language you want and give us the protocol to interact with it? That way we can make bots in curl, netcat, C, Scheme, APL or whatever the fuck we want.

Name: Anonymous 2015-06-26 1:37

New version. Changed some game code a little and added a naive bot that calculates the longest chains for each move on the board and picks a random one from that.

>>10
Why don't you just run a dedicated server
I don't have one.

give us the protocol to interact with it?
Haven't written it yet. What format would you want? sexp? json? I'll just write a scheme bot that proxies move requests over a socket. You can run these all locally.

#!/usr/bin/env chibi-scheme

(import (scheme base) (scheme write) (scheme read) (scheme r5rs) (srfi 27))

;; A lazy list would be better
(define (count-chain-length start-point offset-function still-chain?)
(let loop ((point start-point) (count 0))
(if (not (still-chain? point))
count
(loop (offset-function point) (+ count 1)))))

(define (point-sum point1 point2)
(map + point1 point2))

(define (point-sub point1 point2)
(map - point1 point2))

(define (point-on-board? point board-corner)
(if (not (= (length point) (length board-corner)))
(error "Inconsistent dimensions" point board-corner))
(let loop ((point point) (board-corner board-corner))
(if (null? point)
#t
(and (<= 0 (car point) (- (car board-corner) 1))
(loop (cdr point) (cdr board-corner))))))

(define (point->index point board-corner)
(if (not (= (length point) (length board-corner)))
(error "Inconsistent dimensions" point board-corner))
(let loop ((point point) (board-corner board-corner) (acc 0))
(if (null? point)
acc
(loop (cdr point)
(cdr board-corner)
(+ (car point) (* acc (car board-corner)))))))

(define (board-corner->length board-corner)
(apply * board-corner))

(define (make-board board-corner blank)
(make-vector (board-corner->length board-corner) blank))

(define (board-ref board board-corner point)
(if (not (point-on-board? point board-corner))
(error "Index out of range" point board-corner))
(vector-ref board (point->index point board-corner)))

(define (board-set! board board-corner point value)
(if (not (point-on-board? point board-corner))
(error "Index out of range" point board-corner))
(vector-set! board (point->index point board-corner) value))

(define (player-still-chain? board-read board-corner player)
(lambda (point)
(and (point-on-board? point board-corner)
(eq? player (board-read point)))))

;; Fix the append to make it efficient.
(define (all-bit-strings len)
(if (= len 1)
'((0) (1))
(let ((lower (all-bit-strings (- len 1))))
(append (map (lambda (bit-str) (cons 0 bit-str)) lower)
(map (lambda (bit-str) (cons 1 bit-str)) lower)))))

;; All directions are all non-zero bit strings.
;; all-bit-strings has the zero bit string at the front,
;; so just cdr it.
(define (all-directions dimension)
(cdr (all-bit-strings dimension)))

;; It's assumed that the center point belongs to the player.
(define (find-max-length-of-move point still-chain? all-directions)
(apply max
(map (lambda (direction)
(+ (count-chain-length
(point-sum point direction)
(lambda (p)
(point-sum p direction))
still-chain?) ;; count length going forwards
(count-chain-length
(point-sub point direction)
(lambda (p)
(point-sub p direction))
still-chain?) ;; count length going backwards
1)) ;; center point is not counted.
all-directions)))

;; player -- (player-sym move-function state)

;; move-function -- lambda (board-corner-copy win-length board-read player-syms-copy blank player-sym turn-number actual-moves state) -> move-point

(define (copy-list lis) (map (lambda (x) x) lis))

(define (print val)
(display val)
(newline)
val)

(define (play-game board-corner win-length blank players)
(let* ((max-moves (board-corner->length board-corner))
(board (make-board board-corner blank))
(board-read (lambda (point) (board-ref board board-corner point)))
(player-syms (map car players))
(all-dirs (all-directions (length board-corner))))
(let ((res
(let loop ((players-pos players)
(turn-number 1)
(actual-moves 0)
(move-history '()))
(if (>= actual-moves max-moves)
(print `(tie (board-corner ,board-corner)
(board ,board)
(turn-number ,turn-number)
(actual-moves ,actual-moves)
(move-history ,move-history)))
(let* ((player (car players-pos))
(player-sym (car player))
(move-function (cadr player))
(player-state (caddr player))
(next-players-pos (if (null? (cdr players-pos))
players
(cdr players-pos)))
(player-move (move-function (copy-list board-corner)
win-length
board-read
(copy-list player-syms)
blank
player-sym
turn-number
actual-moves
player-state)))
(if (or (not (list? player-move))
(not (= (length player-move) (length board-corner)))
(not (point-on-board? player-move board-corner))
(not (eq? blank (board-read player-move)))) ;; Invalid move, player forfeits turn.
(loop next-players-pos
(+ turn-number 1)
actual-moves
(cons (print `(,turn-number ,player-sym ,player-move invalid-move))
move-history)))
(begin
(board-set! board board-corner player-move player-sym)
(let* ((still-chain? (player-still-chain? board-read board-corner player-sym))
(move-score (find-max-length-of-move player-move still-chain? all-dirs)))
(if (>= move-score win-length) ;; player wins
(print `(win (winner ,player-sym)
(board-corner ,board-corner)
(board ,board)
(turn-number ,turn-number)
(actual-moves ,actual-moves)
(move-history ,(cons `(,turn-number ,player-sym ,player-move win ,move-score)
move-history))))
(loop next-players-pos
(+ turn-number 1)
(+ actual-moves 1)
(cons (print `(,turn-number ,player-sym ,player-move success ,move-score))
move-history))))))))))
(display-board board-read board-corner)
res)))


(define (display-board board-read board-corner)
(case (length board-corner)
((1) (let display-loop ((index 0))
(when (< index (car board-corner))
(display (board-read (list index)))
(display #\space)
(display-loop (+ index 1))))
(newline))
((2) (let display-row ((row 0))
(when (< row (cadr board-corner))
(let display-row-col ((column 0))
(when (< column (car board-corner))
(display (board-read (list column row)))
(display #\space)
(display-row-col (+ column 1))))
(newline)
(display-row (+ row 1)))))
(else (display "Don't know how..."))))

(define (human-move board-corner win-length board-read player-syms blank player-sym turn-number actual-moves state)
;; display board
(display `(state ,state)) (newline)
(display-board board-read board-corner)
(display (string-append (symbol->string player-sym) "-kun's turn. Make your move."))
(newline)
(read))

(define (range i j)
(if (< i j)
(cons i (range (+ i 1) j))
'()))

(define (board-points board-corner)
(if (null? (cdr board-corner))
(map list (range 0 (car board-corner)))
(let ((lower (board-points (cdr board-corner)))
(current-range (range 0 (car board-corner))))
(apply append
(map (lambda (lower-elt)
(map (lambda (range-elt)
(cons range-elt lower-elt))
current-range))
lower)))))

(define (list-ref lis n)
(if (= n 0)
(car lis)
(list-ref (cdr lis) (- n 1))))

(define (move-score-maximizer board-corner win-length board-read player-syms blank player-sym turn-number actual-moves state)
(let* ((all-dirs (all-directions (length board-corner)))
(all-points (board-points board-corner))
(buckets (make-vector (+ win-length 1) '()))
(process-point (lambda (point)
(when (eq? blank (board-read point))
(let* ((still-chain? (player-still-chain? board-read board-corner player-sym))
(move-score (find-max-length-of-move point still-chain? all-dirs)))
(vector-set! buckets move-score
(cons point
(vector-ref buckets move-score))))))))
(for-each process-point all-points)
(let ((highest-bucket-index
(let loop ((i win-length))
(if (or (< i 0)
(not (null? (vector-ref buckets i))))
i
(loop (- i 1))))))
(when (< highest-bucket-index 0)
(error "No valid moves"))
(let ((bucket (vector-ref buckets highest-bucket-index)))
(list-ref bucket (random-integer (length bucket)))))))

;(play-game '(15 15) 5 '- `((a ,human-move ,(vector 1 2 3)) (b ,human-move ,(vector 2 3 4))))
;(play-game '(15 15) 5 '- `((a ,human-move ,(vector 1 2 3)) (b ,move-score-maximizer ,(vector 2 3 4))))
(play-game '(15 15) 5 '- `((a ,move-score-maximizer ,(vector 1 2 3)) (b ,move-score-maximizer ,(vector 2 3 4))))

Name: Anonymous 2015-06-26 2:04

move-score-maximizers just race to get a line. Not very interesting.

- - - - - - - - - - - - - - -
- - - - - - - - - - - - - - -
- - - - - - - - - - - - - c -
- - - - - - - - - - - - - c -
- - - - - - - - - - - - - c -
- - - - - - - - - - - - - c -
- - - - - - - - - - - - - - -
- - - - - - - - - - b b b b -
- - - - - - - - - - - - - - -
- - - - - - - - - - - - - - -
- - - - - - - - - - - - - - -
- - - - - - - - - - - - - - -
- - - - - - - - - - - - - - -
- - - - a a a a a - - - - - -
- - - - - - - - - - - - - - -

Name: Anonymous 2015-06-26 2:19

s H H
g u u e e Y k k k S S E

- - D - - p - - B d j j j - -
- - - D s - p F F B d - - - -
- - - - s - - p c c c d M - -
- - - - s H H - J - - q M - -
g - u - e Y r r r J - - q - -
g u u e e Y k k k S S E - q -
- g N R R b w - t - - - E - -
- - N - K b P w - t - - n n n
o - - - K b - P - - t - y y m
o - - - - - a L L l - T h h m
o C - A A G I a - l z T - i h
- - C V - G I a f l z x - i i
- - - V - - - Z Z f z - x - X
- - O - - Q Q - - f z - W - X
- - O - U U m - - - z - - W -

Name: Anonymous 2015-06-26 5:48

Now ai2 will respond to threats. If an opponent is about it win, it moves in the way. base64'd the gzipped source because posting the source every time was getting spammy.
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Name: Anonymous 2015-06-26 5:49

avoiding nested subs on tablecat from now on...

Name: Anonymous 2015-06-26 15:07

Gomoku is boring I want to make bots for Unreal Tournament

Name: Anonymous 2015-06-26 20:41

>>16
Go bother Epic Games about the source code and maybe we can actually use them in the game.

Name: Anonymous 2015-06-26 21:14

>>16
I agree.

>>17
Or we can just write our own Unreal Tournament. Or use a similar game where the code has been released like Quake.

Name: Anonymous 2015-06-27 1:21

What about danmaku? Can that be versus?

Name: Anonymous 2015-06-27 1:26

I ARE REALLY ANDRU.

Name: Anonymous 2015-06-27 2:52

>>18
Assaultcube is nice.

Name: Anonymous 2015-06-27 5:18

>>21
The only good open source games used to be commercial. There are no exceptions. What about counter-strike 1.6? I heard valve released the source to that and there is a linux port. Either that or it was leaked. I can't remember now.

Name: Anonymous 2015-06-27 5:28

Although I was hoping to program rocket jumping.

Name: Anonymous 2015-06-27 20:32

Oh ho! Look what I found!
https://github.com/ValveSoftware/halflife

Name: Anonymous 2015-06-27 20:48

An open source binary compatible engine for halflife games. It's windows only right now though.
http://code.google.com/p/sing-engine/

Name: Anonymous 2015-06-28 2:44

If noone says anything I'm just going to make a versus danmaku that puts robocode to shame.

Name: Anonymous 2015-06-28 2:54

>>26
I'll participate only if I can play as Marisa.

Name: Anonymous 2015-06-28 3:36

>>27
Is there any public domain touhou game art I can use that you know of?

Name: Anonymous 2015-06-29 4:24

What spatial data structure should I used for danmaku? Naive check collisions between all pairs wouldn't be so bad because you only need to check between the player and unfriendly bullets.

Name: Anonymous 2015-06-29 13:34

>>29
it's O(n) to loop through all bullets and test again the player, you're not going to get better than that.

Name: Anonymous 2015-06-29 16:16

>>30
Yeah, but then the AIs will need to rescan the bullets for dodging purposes. I think I'll throw them into buckets by distance from their enemy player so players can loop through bullets that are within certain distance categories.

Name: Cudder !cXCudderUE 2015-06-29 17:53

You have to loop through all bullets to update their positions anyway. Even if you have several thousand, the CPU can do a million times more operations per second.

Name: Anonymous 2015-06-29 18:45

CHAR N CUDDER
CHAR N CUDDER
CHAR N CUDDER
CUDDER
CUDDER
CHAR N CUDDER
CHAR N CUDDER
CHAR N CUDDER
CUDDER
CUDDER
Newer Posts
Don't change these.
Name: Email:
Entire Thread Thread List
All trademarks and copyrights on this site are owned by their respective parties. All comments and posts are the responsibility of their own posters.
- Tinychan + 2ch Mode + RSS -