#!/usr/bin/python

import gobject
from gtk import *
from gnome.ui import *
import gnome.canvas
import gtk.gdk 
import whrandom
import cowries

# A game of Untee.

# Square positions
#
# 0  15 14 13 12
# 1  16 17 18 11
# 2  23 ** 19 10
# 3  22 21 20 9
# 4  5  6  7  8

PIXMAP_ROOT = '/usr/share/pixmaps/pygnome-games/'

square_pos = [  [0,15,14,13,12], 
				[1,16,17,18,11], 
				[2,23,24,19,10], 
				[3,22,21,20,9], 
				[4,5,6,7,8] ]

SQSIDE = 90

# Stores players' state

class UPlayers:
	paths = [
		range(2,16) + [0,1] + range(16,25),
		range(10,16) + range(10) + [20,21,22,23,16,17,18,19,24],
		range(6,16) + range(6) + [22,23,16,17,18,19,20,21,24],
		[14,15] + range(14) + [18,19,20,21,22,23,16,17,24]
		]
		
	pindex = [ [], [], [], [] ]
	for j in range(25):
		for p in range(4):
			i = paths[p].index(j)
			pindex[p].append(i)

	def __init__(self,number):
		self.players = number
		self.positions = [  [2,2,2,2],
							[10,10,10,10],
							[6,6,6,6],
							[14,14,14,14]
						 ]
		return
	
	# Determines whether player can move forward by an amount
	# from a specified starting square. Returns destination square
	# if possible, else -1
	def can_move(self,player,from_sqr,moves):
		pos = self.pindex[player][from_sqr]
		dest_pos = pos+moves
		if dest_pos > 24:
			return -1
		else:
			return self.paths[player][dest_pos]
	
	# Move 'num' tokens of 'player' from initial square to destination
	def move_tokens(self,player,num,from_sqr,dest_sqr):
		if dest_sqr == 24:
			for j in range(num):
				self.positions[player].remove(from_sqr)
		else:
			for j in range(num):
				ind = self.positions[player].index(from_sqr)
				self.positions[player][ind] = dest_sqr
		return
	
	def player_pos(self,player):
		return self.positions[player]

class UImages:
	"Provides simple interface for pixmap handling"

	def __init__(self):
		self.files = { 'red.xpm': 'red',
				  'blue.xpm': 'blue',
				  'green.xpm': 'green',
				  'brown.xpm': 'brown',
				  'check.xpm': 'check',
				  'home.xpm': 'home',
				}
		self.pixbufs = {}

		return

	def init_pixmaps(self):
		for fname in self.files.keys():
			pkey = self.files[fname]
			pixfile = PIXMAP_ROOT+fname
			pmap = gdk.pixbuf_new_from_file(pixfile)	
			self.pixbufs[pkey] = pmap

	# This function returns a gtk Image from UPixmap key
	def make_pixmap(self,key):
		pbuf = self.pixbufs[key]
		img = Image()
		img.set_from_pixbuf(pbuf)
		return img

# Create a global object

untee_pmaps = UImages()

class USquare:
	"A square on an Untee board"
	
	token_side = 20
	offset = 5
	colors = [ 'red', 'blue', '#007d00', '#94302d']

	def __init__(self,y,x,root,cb):
		self.index = square_pos[y][x]
		self.occupants = [0,0,0,0]
		self.tokens = [ [], [], [], [] ]
		self.croot = root
		
		self.xoff = x*SQSIDE
		self.yoff = y*SQSIDE
		self.back = self.make_back()
		self.back.move(self.xoff,self.yoff)
		
		if self.index != 24:
			self.back.connect('event',cb,self)
		return
	
	def make_back(self):
		if self.index == 24:
			backg = untee_pmaps.make_pixmap('home')
			w = self.croot.add(gnome.canvas.CanvasWidget, widget=backg, x=0, y=0, 
				width=SQSIDE, height=SQSIDE, size_pixels=TRUE)
			return w

		wun = 3
		if self.index == 2:
			fcol = '#ffe5e5'
			ocol = '#ff0000'
		elif self.index == 10:
			fcol = '#e5e5ff'
			ocol = '#0000ff'
		elif self.index == 6:
			fcol = '#e5ffe5'
			ocol = '#007d00'
		elif self.index == 14:
			fcol = '#dac6bd'
			ocol = '#94302d'
		else:
			fcol = '#ffffff'
			ocol = '#000000'
			wun = 1
		w = self.croot.add(gnome.canvas.CanvasRect, x1=0, y1=0, x2=SQSIDE, y2=SQSIDE,
						fill_color=fcol, outline_color=ocol, width_units=wun)
		return w
	
	def new_tokens(self, player, amt):
		x1 = self.offset + self.xoff
		y1 = self.offset + player*self.token_side + self.yoff
		y2 = y1 + self.token_side
		color = self.colors[player]
		self.occupants[player] = amt

		for j in range(amt):
			x2 = x1 + self.token_side
			w = self.croot.add(gnome.canvas.CanvasEllipse, x1=x1, y1=y1, x2=x2, y2=y2,
							fill_color=color, outline_color='black',
							width_units = 1.0)
			self.tokens[player].append((w,x1,y1))
			x1 = x2
		return
		
	def move_into(self, player, wids):
		amt = len(wids)
		occ = self.occupants[player]
		x1 = self.offset + self.xoff + occ*self.token_side
		y1 = self.offset + player*self.token_side + self.yoff

		for j in range(amt):
			w,xpos,ypos = wids[j]
			w.move(x1-xpos, y1-ypos)
			self.tokens[player].append((w,x1,y1))
			x1 = x1 + self.token_side
		
		self.occupants[player] = occ + amt
		return
		
	def move_outof(self, player, amt):
		occ = self.occupants[player] - amt
		wids = self.tokens[player][occ:]
		self.tokens[player][occ:] = []
		self.occupants[player] = occ
		return wids
	
	def empty_out(self):
		for i in range(4):
			for j in range(self.occupants[i]):
				wid,x,y = self.tokens[i][j]
				wid.destroy()
		self.occupants = [0,0,0,0]
		self.tokens = [ [], [], [], [] ]
		return
	
# Determines number of tokens player desires to move.

class FindNum:
	
	labels = [ '','Singlet (1)','Doublet (2)','Triplet (3)','Quadruplet (4)']

	def __init__(self,chlist):
		getinfo = gtk.Dialog("Untee!",None,0,(gtk.STOCK_OK, gtk.RESPONSE_OK))
		self.index = 0
		vb = getinfo.vbox
		vb.set_homogeneous(0)
		vb.set_spacing(3)

		self.do_pack(vb,chlist)
		self.retcode = getinfo.run()
		getinfo.destroy()
	
	def do_pack(self,vbox,chlist):
		frame = Frame('Move Selector')
		vbox.pack_start(frame,TRUE,TRUE,2)
		vb = VBox(FALSE,6)
		vb.set_border_width(3)
		frame.add(vb)
		
		header = Label('Select number of tokens to move')
		vb.pack_start(header,TRUE,TRUE,4)
		header.show()
		
		radiob = [ RadioButton(None,self.labels[chlist[0]]) ]
		for j in range(1,len(chlist)):
			rb = RadioButton(radiob[0],self.labels[chlist[j]])
			radiob.append(rb)

		radiob[0].set_active(TRUE)
		for j in range(len(chlist)):
			vb.pack_end(radiob[j],FALSE,FALSE,3)
			radiob[j].connect('toggled',self.callback,j)
			radiob[j].show()
		
		vb.show()
		frame.show()
		vbox.show()
		return
	
	def callback(self,widget,data):
		if widget.get_active():
			self.index = data

# Queries number of players and their names. Used before starting 
# a new game.

class StartUp:
	"Start Game of Untee"

	def select_players(self,cbox,data):
		i = 4 - cbox.get_active()
		self.players = i
		for j in range(i):
			self.plabs[j].show()
			self.pnames[j].show()
		for j in range(i, 4):
			self.plabs[j].hide()
			self.pnames[j].hide()
		return

	def __init__(self, pnames):
		start = gtk.Dialog("Untee!", None, 0, (gtk.STOCK_OK, gtk.RESPONSE_OK))

		self.players = 4
		self.pnames = []	
		self.plabs = []
		self.retcode = 0

		vb = start.vbox
		vb.set_homogeneous(0);
		vb.set_spacing(2);

		optmenu = gtk.combo_box_new_text()
		selpnum = Label("Select number of players")
		selpnum.show()
		for j in range(3):
			optmenu.prepend_text("%d" % (j+2))
		optmenu.set_active(0)
		optmenu.connect('changed', self.select_players, None)
		
		optmenu.show()
		hbox = HBox(FALSE,1)
		hbox.pack_start(selpnum,TRUE,TRUE,1)
		hbox.pack_start(optmenu,TRUE,FALSE,1)
		hbox.show()

		vb.pack_start(hbox,TRUE,TRUE,2)
		hsep = HSeparator()
		hsep.show()
		vb.pack_start(hsep,TRUE,TRUE,2)

		hboxes = []
		for j in range(4):
			plab = Label("Player %d: " % (j+1))
			plab.show()
			pname = gtk.Entry()
			# pname.set_text("player%d" % (j+1))
			pname.set_text(pnames[j])
			pname.show()
			hb = HBox(FALSE,0)
			hb.pack_start(plab,TRUE,TRUE,2)
			hb.pack_start(pname,TRUE,TRUE,2)
			hb.show()
			self.plabs.append(plab)
			self.pnames.append(pname)
			hboxes.append(hb)
			vb.pack_start(hb,TRUE,TRUE,2)

		vb.show()
		self.retcode = start.run()
		if self.retcode == gtk.RESPONSE_OK:
			self.names = []
			for j in range(self.players):
				self.names.append(self.pnames[j].get_text())
		start.destroy()

	def player_names(self):
		if self.retcode != gtk.RESPONSE_OK:
			return []
		else:
			return self.names

####################################################################

# The main class, representing state of the game and UI.

class Untee:

	move_val = [4, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 8]
	homes = [2,10,6,14]

	def __init__(self):
		# Read in xpm files
		untee_pmaps.init_pixmaps()
		
		self.pnames = ['Ashok','Vikramaditya','Rajaraj', 'Shah Jehan']
		self.pkeys = [ 'red','blue','green','brown' ]
		self.players = 4
		self.current = 0
		self.squares = []

		# This is for the move controls
		self.rollable = 0
		self.movable = 0
		self.available = []

		# This is for the player chart
		self.checks = []
		self.picons = []
		self.plabels = []

		gapp = App('Untee','Untee!')
		gapp.connect('delete_event',main_quit)
		gapp.connect('destroy',main_quit)
		self.app = gapp

		self.create_menus()
		self.create_contents()
		gapp.set_resizable(True)
		gapp.show_all()
	
	def create_menus(self):
		gameinfo = [
			('GameMenu', None, '_Game'),
			('HelpMenu', None, '_Help'),
			('New', gtk.STOCK_NEW, '_New', '<control>N', 'Start a New Game', 
			self.new_game),
			('Quit', gtk.STOCK_QUIT, '_Quit', '<control>Q', 'Quit Game', gtk.main_quit),
			('Save', gtk.STOCK_SAVE, '_Save', '<control>S', 'Save current game to file', 
			 self.not_yet),
			('Load', gtk.STOCK_OPEN, '_Load', '<control>O', 'Load game from file', 
			 self.not_yet),
			('About', gtk.STOCK_DIALOG_INFO, '_About', None, 'About Untee', self.about)
		]
		uiinfo = '''<ui>
					<menubar name = 'MenuBar'>
					<menu action = 'GameMenu'>
						<menuitem action = 'New'/>
						<menuitem action = 'Save'/>
						<menuitem action = 'Load'/>
						<menuitem action = 'Quit'/>
					</menu>
					<menu action = 'HelpMenu'>
						<menuitem action = 'About'/>
					</menu>
					</menubar>
					<toolbar name = 'ToolBar'>
						<toolitem action = 'New'/>
						<toolitem action = 'Quit'/>
						<separator/>
						<toolitem action = 'Save'/>
						<toolitem action = 'Load'/>
						<separator/>
						<toolitem action = 'About'/>
					</toolbar>
					</ui>
				'''
		act_grp = gtk.ActionGroup('MainGroup')
		act_grp.add_actions(gameinfo)
		uim = gtk.UIManager()
		uim.insert_action_group(act_grp, 0)
		uim.add_ui_from_string(uiinfo)
		tbar = uim.get_widget('/ToolBar')
		tbar.set_tooltips(True)
		tbar.show()
		mbar = uim.get_widget('/MenuBar')
		mbar.show()
		self.app.set_toolbar(tbar)
		self.app.set_menus(mbar)
		
		return	

	def new_game(self,i):
		su = StartUp(self.pnames)
		tmp = su.player_names()
		print tmp
		if (tmp != []):
			self.pnames = tmp
			self.players = len(self.pnames)
			self.current = 0
			self.refresh_players()
			self.set_tokens()
			self.rollable = 1
			self.player_info = UPlayers(self.players)
			return
	
	def set_tokens(self):
		l = len(self.squares)
		for j in range(l):
			self.squares[j].empty_out()
		for j in range(self.players):
			self.squares[self.homes[j]].new_tokens(j,4)
	
	def about(self,i):
		win = gnome.ui.About('Untee','0.3','GNU Public License', 'A Strategy Game from India',
			['Vaibhav Vaish', 'vaibhav@stanford.edu'])
		win.show()
	
	def not_yet(self,i):
		gnome.ui.gnome_error_dialog('This feature is not supported\n in this version of Untee')
		return

	def create_contents(self):
		hbox = HBox(FALSE,0)
		vbox = VBox(FALSE,2)
		grid = gnome.canvas.Canvas()
		grid.set_size_request(5*SQSIDE, 5*SQSIDE)
		grid.set_scroll_region(0,0,5*SQSIDE,5*SQSIDE)

		hbox.pack_start(vbox,TRUE,TRUE,6)
		hbox.pack_start(grid,FALSE,TRUE,0)
		self.create_board(grid)
		self.create_players(vbox)
		self.create_kchart(vbox)
		grid.show()
		vbox.show()
		hbox.show()
		self.app.set_contents(hbox)

	def create_board(self,canvas):
		for k in range(25):
			self.squares.append(None)

		grid = canvas.root()
		for i in range(5):
			for j in range(5):
				sqr = USquare(i,j,grid,self.pressed)
				self.squares[sqr.index] = sqr
		return
	
	def create_players(self,vbx):

		frame = Frame("Players")
		vbx.pack_start(frame, FALSE, TRUE, 6)
		vb = VBox(TRUE,2)
		frame.add(vb)

		for j in range(self.players):
			hbox = HBox(FALSE,3)
			vb.pack_start(hbox, FALSE, TRUE, 2)
			
			pix = untee_pmaps.make_pixmap(self.pkeys[j])
			chk = untee_pmaps.make_pixmap('check')
			lab = Label(self.pnames[j])
			
			self.picons.append(pix)
			self.checks.append(chk)
			self.plabels.append(lab)

			hbox.pack_start(pix,FALSE,TRUE,1)
			hbox.pack_start(lab,FALSE,TRUE,1)
			hbox.pack_end(chk,TRUE,TRUE,1)
			pix.show()
			lab.show()
			hbox.show()

		self.checks[self.current].show()
		vb.show()
		frame.show()
		
	def refresh_players(self):
		for j in range(4):
			self.checks[j].hide()
			if (j < self.players):
				self.plabels[j].set_text(self.pnames[j])
				self.plabels[j].show()
				self.picons[j].show()
			else:
				self.plabels[j].hide()
				self.picons[j].hide()
		self.checks[self.current].show()
		return
	
	def create_kchart(self,vbox):
		frame = Frame("Move Panel")
		vbox.pack_start(frame, False, True, 2)
		hb = HBox(TRUE,6)
		vb = VBox(False,4)
		frame.add(hb)
		hb.pack_start(vb,True,True,2)

		# create tree view for displaying list of moves
		kchart = cowries.UCowrieChart(PIXMAP_ROOT, self.move_val)
		kchart.set_size_request(120,130)
		vb.pack_start(kchart,True,True,2)

		# create button to roll kaudis
		roll = Button('Roll')
		roll.connect('clicked',self.rolled)
		vb.pack_end(roll,FALSE,False,2)
		self.kchart = kchart
		
		roll.show()
		kchart.show()
		vb.show()
		hb.show()
		frame.show()

	# Methods for move management

	# Called when none of the available moves is valid.
	def failed_move(self):
		sel = self.kchart.get_selection()
		sel.unselect_all()
		sel.set_mode(gtk.SELECTION_NONE)
		gnome_error_dialog('No move possible.')
		self.next_move()
	
	# Called when it is next player's turn.
	def next_move(self):
		self.checks[self.current].hide()
		self.current = (self.current+1) % self.players
		self.checks[self.current].show()
	
	def pressed(self,wid,event,sqr):
		if event.type != gdk.BUTTON_PRESS:
			return 
		if not self.movable:
			return
		
		curr = sqr.occupants[self.current]
		total = self.kchart.total()

		if curr == 0:
			gnome.ui.gnome_error_dialog('You have no tokens in this box.')
			return
		if total == 0:
			gnome.ui.gnome_error_dialog('You need to select at least one move.')
			return
		
		num,dest = self.get_number(sqr.index,total)
		if num < 0:
			return			# user cancelled this choice
		if dest < 0:
			gnome.ui.gnome_error_dialog('Illegal move.')
			return
		
		# Move is legal. Execute move, and check if more moves are left.
		self.exec_move(num,sqr.index,dest)

		# Check if game is over ...
		if dest == 24 and self.player_info.player_pos(self.current) == []:
			self.game_over()
			return
		
		# Check if valid moves are left
		if self.available == []:
			self.rollable = TRUE
			self.movable = FALSE
			self.next_move()
		elif self.check_valid():
			self.rollable = FALSE
			self.movable = TRUE
			if len(self.available) == 1:
				self.kchart.get_selection().select_all()
		else:
			self.rollable = TRUE
			self.movable = FALSE
			self.failed_move()
		return
	
	# Determines number of tokens to be moved from chosen square.
	def get_number(self,start,moves):
		choices = []
		dests = []
		tokens = self.squares[start].occupants[self.current]

		for j in range(1,tokens+1):
			movelen,rem = divmod(moves,j)
			if rem == 0:
				dest = self.player_info.can_move(self.current,
						start,movelen)
				if dest >= 0:
					choices.append(j)
					dests.append(dest)

		num_ch = len(choices)
		if num_ch == 0:
			return 0,-1
		elif num_ch == 1:
			return choices[0],dests[0]
		else:
			fnum = FindNum(choices)
			if fnum.retcode == gtk.RESPONSE_OK:
				ch_index = fnum.index
				return choices[ch_index],dests[ch_index]
			else:
				return -1, 0
	
	# Moves 'num' tokens of current player from 'start' to 'dest'
	# In case of killing/home, kaudis are rolled as needed. Returns
	# boolean indicating whether any valid moves are left.
	def exec_move(self,num,start,dest):
		self.player_info.move_tokens(self.current,num,start,dest)
		wids = self.squares[start].move_outof(self.current,num)
		self.del_selected()

		# First check if some tokens have been homed. Destroy them!
		if dest == 24:
			for j in range(num):
				w,x,y = wids[j]
				w.destroy()
			if self.player_info.player_pos(self.current) == []:
				# Game over. RIP.
				return 
			self.append_moves(num)
			return 
		
		# Now check for killing.
		kill = self.killed(num,dest)
		if kill == None:
			self.squares[dest].move_into(self.current,wids)
			return 

		# Somebody got killed ...
		self.player_info.move_tokens(kill,num,dest,self.homes[kill])
		kwids = self.squares[dest].move_outof(kill,num)
		self.squares[self.homes[kill]].move_into(kill,kwids)
		self.squares[dest].move_into(self.current,wids)
		self.append_moves(num)
		return 
	
	# check whether there's a killing
	def killed(self,num,dest):
		for j in range(4):
			if dest == self.homes[j]:
				return None

		if self.squares[dest].occupants[self.current] > 0:
			return None

		occs = 0
		ply = None
		for j in range(self.players):
			tokens = self.squares[dest].occupants[j]
			if tokens > 0:
				occs = occs + 1
			if tokens == num:
				ply = j

		if occs == 1:
			return ply
		else:
			return None
	
	# extra moves for killing/homing
	def append_moves(self,num):
		new_moves = []
		for j in range(num):
			new_moves = new_moves+self.roll_kaudis()

		self.available = self.available + map(lambda x: self.move_val[x], new_moves)
		self.kchart.append_moves(new_moves, False)
		return
	
	# Delete selected moves after move execution
	def del_selected(self):
		indices = self.kchart.delete_moves()
		indices.reverse()
		for j in indices:
			del self.available[j]
		return
	
	# Methods for rolling, validity checking

	def rolled(self,dat):
		if not self.rollable:
			return
	
		self.new_moves()
		if not self.check_valid():
			self.failed_move()
			return
		
		if len(self.available) == 1:
			self.kchart.get_selection().select_all()
		self.rollable = 0
		self.movable = 1
		return
	
	# Rolls kaudis and returns list of kaudi ids
	def roll_kaudis(self):
		kd = whrandom.randint(0,15)
		val = [ kd ]

		while (kd == 15 and len(val) < 3):
			kd = whrandom.randint(0,15)
			val.append(kd)
		
		if (len(val) == 3 and val[2] == 15):
			return []
		else:
			return val

	def new_moves(self):
		moves = self.roll_kaudis()
		self.available = map(lambda x: self.move_val[x], moves)
		self.kchart.append_moves(moves, True)
		return

	# Checks validity of available moves for current player.
	# If no valid moves, player loses turn.
	def check_valid(self):
		posit = self.player_info.player_pos(self.current)
		rows = 0
		num_moves = len(self.available)
		valid = 0
		j = 0
		
		while j<num_moves and not valid:
			move = self.available[j]
			for pos in posit:
				tokens = self.squares[pos].occupants[self.current]
				for n in range(1,tokens+1):
					movelen,rem = divmod(move,n)
					if rem == 0:
						dest = self.player_info.can_move(self.current,
								 pos,movelen)
						if dest >= 0:
							valid = 1
#							vn, vpos, vmovelen = n, pos, movelen
			j = j+1

#		if valid:
#			print 'Can move ', vn, 'token(s) from position ', vpos, 'by ', vmovelen
		return valid
	
	# When the game has been won ...
	def game_over(self):
		self.rollable = FALSE
		self.movable = FALSE
		name = self.pnames[self.current]
		msg = 'Congratulations, '+name+'! You have won!'
		popup = gnome_ok_dialog_parented(msg, self.app)
		popup.run_and_close()
		return

a = Untee()
gtk.main()
