|
Developing Games That Learn Leonard Dorfman and Narendra K. Ghosh 1996 | 300 pages ISBN: 135696178 |
|||
| $34.95 | Softbound print book | Out of print (?) | |
Index
Aadd_list(...) function 229-231
add_pattern_list(...) function 250-251
artificial intelligence, objective. See objective artificial intelligence
awareness, definition 3
B
balance, program learning and program instinct 60
C
check_for_loss(...) function 155-157
check_for_pattern(...) function 203-205
check_for_win(...) function 154-155
close_data_base(...) function 272-273
coffin[] array, role in move generation in Drop Four 101-114
coffin_corner( UCHAR turn ) function 113
coffin_pattern(turn) function 111-112
consciousness models, human and computer 2-5, 7, 12
create_coffin(...) function 105-107
create_coffin_o(opponent) function 108-109
create_setup2(...) function 157-159
create_win_board() function 110-111
D
disk access functions 269-273
do_positional_move(...) function 166-167
double wins 150
Drop Four (game). See also forced move algorithm
adding a move to the move list 229-231
coffin[] array, role in move generation 101-114
double wins, determining 150
evaluation_first_ply[8] array 206
first-move selection 115-143, 231-236
function map 75-80
functions. See functions
getting number of pieces in a game board column 149
implementation overview 52-59, 70
initializing ghost boards 148
level-two analysis support function 233
levels of play 116-118
marker disruption implementation 239-250
move generation, basic concepts 101-114
move generation, positional 201-227
move selection implementation 73-100
move selection sequence design 68-69
option settings for game play 80-86
overview and analysis 49-60
pattern matching 165-199
ply searching 145-163
positional moves, non-ply 166-199
program learning 1-2, 70-71, 229-267
raw_score array 206
relocating data between boards 148-149
searching for wins 152-155
second move computer analysis 235
three-filled patterns 202-205
weights[8] array 206
wins on ghost boards, determining 151
E
evaluate_board(...) function 205-227
evaluation_first_ply[8] array 206
F
find_winning_pattern(...) function 253-256
first-move analysis in Drop Four game 231-236
first_human_win(...) function 259-260
first_move_analysis(...) function 231-232
first_move_check(...) function 256-257
first_pat_analysis(...) function 239-250
first_ply_move(...) function 205-207
forced move algorithm. See also program learning; objective artificial intelligence
coding 16-28
conditions for failure 13
conditions for success 53
synergy with three-filled marker disruption algorithm 253
theoretical basis 63-65, 70-71
use 100, 229, 231, 237
forced move, definition 15, 63
forced-win search 157-159
forks, blocking 161-163
four-in-a-row games 50. See also Drop Four
function
add_list(...) 229-231
add_pattern_list(...) 250-251
check_for_loss(...) 155-157
check_for_pattern(...) 203-205
check_for_win(...) 154-155
close_data_base(...) 272-273
coffin_corner( UCHAR turn ) 113
coffin_pattern(turn) 111-112
create_coffin(...) 105-107
create_coffin_o(opponent) 108-109
create_setup2(...) 157-159
create_win_board() 110-111
determining double wins 150
determining wins on ghost boards 151
disk access 269-273
do_positional_move(...) 166-167
evaluate_board(...) 205-227
find_winning_pattern(...) 253-256
first_human_win(...) 259-260
first_move_analysis(...) 231-232
first_move_check(...) 256-257
first_pat_analysis(...) 239-250
first_ply_move(...) 205-207
get_computer_move(...) 115
get_computer_move_first(...) 115-143
getting number of pieces in column 149
init_coffin() 105
initializing ghost boards 148
input/output 269-273
look_ahead_opp(...) 161-163
map 75-80
off_first_human_win(...) 262-263
off_first_move_analysis(...) 236
off_first_move_check(...) 265-266
off_second_human_win(...) 263-265
off_second_move_analysis(...) 237
off_second_move_check(...) 266-267
off_second_move_comp_analysis(...) 238
open_data_base(...) 269-271
opening_book_defensive(...) 171-190
opening_book_first(...) 167-170
opening_book_offensive(...) 191-199
opponent_type_move(...) 233
pattern_search_board(...) 202
ply search 145-163
relocating data between boards 148-149
searching for wins 152-155
second_human_win(...) 260-262
second_move_analysis(...) 234
second_move_check(...) 258-259
second_move_comp_analysis(...) 235
start_game(...) 86-99
stop_setup2(...) 159-161
G
game design. See Drop Four; Tic Tac Toe
get_computer_move(...) function 115
get_computer_move_first(...) function 115-143
ghost boards 146-155, 203
H
human consciousness, model 2-4
I
init_coffin() function 105
initializing ghost boards 148
input/output functions 269-273
instinct, program. See program instinct
K
kiss of death move theory 63-65, 229
L
learning, program. See program learning
level-two analysis support function 233
look_ahead_opp(...) function 161-163
loss analysis 229-267
M
marker disruption 53, 71, 239-250
memory
definitions 2
markers 2, 5-6, 66-67, 229
role in program learning 1
move elimination algorithm 13, 31-47. See also objective artificial intelligence
move generation 201-227
O
objective artificial intelligence
analysis 11, 14-15, 53-59
definition 1-2, 6
design overview 11-12, 15-16, 61-72
implementation overview 9-16, 52-59
problem statement 10-11, 14, 52
suitability for application 7-9, 14, 51-52
off_first_human_win(...) function 262-263
off_first_move_analysis(...) function 236
off_first_move_check(...) function 265
off_second_human_win(...) function 263-265
off_second_move_analysis(...) function 237
off_second_move_check(...) function 266
off_second_move_comp_analysis(...) function 238
open_data_base(...) function 269-271
opening book moves in game design 167-199
opening_book_defensive(...) function 171-190
opening_book_first(...) function 167-170
opening_book_offensive(...) function 191-199
opponent_type_move(...) function 233
P
pattern analysis after game completion 229
pattern recognition and matching 71, 165-199, 202-203, 239-256
pattern_search_board(...) function 202
ply searching 145-163
position evaluation in board game theory 201-102, 205-227
positional moves in game design 166-199
program consciousness 4-5, 7, 12
program instinct
basic concepts 101-114
coffin[] array 101-114
definition 7
design and implementation 29-31, 54-59, 69-70
move decision scheme 115-143
non-ply positional moves 166-199
opening book defensive moves 171-190
opening book offensive moves 191-199
pattern matching 165-199
ply searching 145-163
positional move generation 201-227
purpose 13
program learning. See also objective artificial intelligence; forced move algorithm; marker disruption algorithm; move elimination algorithm
analyzing a loss 229-252
definition 7
design principles in Drop Four 70-71
effectiveness in Drop Four 1-2
implementation in Drop Four 253-267
role of memory 1
programming environment and tools 67
R
raw_score array 206
S
second-move analysis in Drop Four 231-236, 238
second_human_win(...) function 260-262
second_move_analysis(...) function 234
second_move_check(...) function 258-259
second_move_comp_analysis(...) 235
start_game(...) function 86-99
stop_setup2(...) function 159-161
subconsciousness, computer 5, 12
T
three-filled marker disruption algorithm 71, 100, 253. See also objective artificial intelligence; program learning
three-filled patterns 202-205, 250-251
Tic Tac Toe 13-48
U
unconsciousness, computer 5, 12
W
weights[8] array 206
win_board array 110-111
DESCRIPTION
If you've ever wondered how to empower your software with the ability to learn from experience, this book is for you. Developing Games That Learn shows in detail how to implement single-trial learning, illustrating its approach in board games Tic Tac Toe and a more complex game called Drop Four. The authors discuss the learning algorithms and present the source code that implements them.The program learning techniques are presented in sufficient detail to be useful for practical software design. They are particularly suited to computer game development, but can also be used in other areas. This book provides valuable guidance for programmers, project leaders, and game designers.
Existing approaches to program learning are often of the "dumb" type-the program simply learns not to repeat any sequence that led to failure. Authors Dorfman and Ghosh take a more powerful path: for each example of failure, their method first finds the point of no return-the point after which the game was certain to be lost. Then that point is prevented from being reached via any of a number of different (but equivalent) paths, not just the single path actually played, thus accelerating the learning.
If you are interested in using these techniques in applications other than games, the authors discuss ways to do that.
ABOUT THE AUTHORS...
Leonard Dorfman, Ph.D., is the author of 22 computer science books, concentrating on C, C++, and Assembly language, a black comic novel, and four commercial software products. He has a strong background in educational research, and interest in psychology, philosophy, and Buddhist studies. He's a teacher and writer, and keeps shop at MultiGrain Solutions, a software development company.Narendra K. Ghosh is currently obtaining a degree in computer science from Harvard University. He worked cooperatively with Len in developing Objective Artificial Intelligence and the learning algorithms, and in implementing the code used in the demonstration programs.