#!/usr/bin/python

from gtk import *
import GtkExtra
from gnome.ui import *
from GDK import *
import whrandom

# 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/untee/'

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 UPixmaps:
	"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.pmsk = {}
		self.bmsk = {}

		return

	def init_pixmaps(self,parent):
		for fname in self.files.keys():
			pkey = self.files[fname]
			pixfile = PIXMAP_ROOT+fname
			pmap, bmap = create_pixmap_from_xpm(parent,None,pixfile)	
			self.pmsk[pkey] = pmap
			self.bmsk[pkey] = bmap

	# This function returns a GtkPixmap from UPixmap key
	def make_pixmap(self,key):
		pm = self.pmsk[key]
		bm = self.bmsk[key]
		pixmap = GtkPixmap(pm,bm)
		return pixmap

# Create a global object

untee_pmaps = UPixmaps()

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('widget', 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('rect', 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('ellipse', 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 = GnomeDialog("Untee!",STOCK_BUTTON_OK)
		getinfo.connect('destroy', getinfo.close)
		self.index = 0
		vb = getinfo.vbox
		vb.set_homogeneous(0)
		vb.set_spacing(3)

		self.do_pack(vb,chlist)
		getinfo.run_and_close()
	
	def do_pack(self,vbox,chlist):
		frame = GtkFrame('Move Selector')
		vbox.pack_start(frame,TRUE,TRUE,2)
		vb = GtkVBox(FALSE,6)
		vb.set_border_width(3)
		frame.add(vb)
		
		header = GtkLabel('Select number of tokens to move')
		vb.pack_start(header,TRUE,TRUE,4)
		header.show()
		
		radiob = [ GtkRadioButton(None,self.labels[chlist[0]]) ]
		for j in range(1,len(chlist)):
			rb = GtkRadioButton(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.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,obj,i):
		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):
		start = GnomeDialog("Untee!",STOCK_BUTTON_OK)
		start.connect('destroy', start.close)
		start.set_default(0)

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

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

		optmenu = GtkOptionMenu()
		menu = GtkMenu()
		selpnum = GtkLabel("Select number of players")
		selpnum.show()
		for j in range(3):
			item = GtkMenuItem("%d" % (j+2))
			menu.prepend(item)
			item.connect('activate',self.select_players,j+2)
			item.show()
		
		optmenu.set_menu(menu)
		optmenu.show()
		hbox = GtkHBox(FALSE,1)
		hbox.pack_start(optmenu,TRUE,FALSE,1)
		hbox.pack_start(selpnum,TRUE,TRUE,1)
		hbox.show()

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

		hboxes = []
		for j in range(4):
			plab = GtkLabel("Player %d: " % (j+1))
			plab.show()
			pname = GtkEntry()
			pname.set_text("player%d" % (j+1))
			pname.show()
			hb = GtkHBox(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_and_close()

	def player_names(self):
		if self.retcode != 0:
			return []
		else:
			names = []
			for j in range(self.players):
				nm = self.pnames[j].get_text()
				if nm == '':
					nm = "player%d" % (j+1)
				names.append(nm)
			return names

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

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

class Untee:

	homes = [2,10,6,14]

	def __init__(self):
		self.pnames = ['player1','player2','player3','player4']
		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 = GnomeApp('Untee','Untee!')
		gapp.connect('delete_event',mainquit)
		gapp.connect('destroy',mainquit)
		untee_pmaps.init_pixmaps(gapp)
		self.app = gapp

		self.create_menus()
		self.create_contents()
		gapp.set_policy(TRUE, TRUE, TRUE)
		gapp.show_all()
	
	def create_menus(self):
		gameinfo = [
			(APP_UI_ITEM, 'New', 'Start a New Game', self.new_game, None,
			 APP_PIXMAP_STOCK, STOCK_MENU_NEW, 0, 0),
			(APP_UI_ITEM, 'Save', 'Save current game to file', 
			 self.not_yet, None, APP_PIXMAP_STOCK, STOCK_MENU_SAVE, 0, 0),
			(APP_UI_ITEM, 'Load', 'Load game from file', 
			 self.not_yet, None, APP_PIXMAP_STOCK, STOCK_MENU_OPEN, 0, 0),
			(APP_UI_ITEM, 'Exit', None, mainquit, None,
			 APP_PIXMAP_STOCK, STOCK_MENU_EXIT, 0, 0)
		]
		helpinfo = [
			(APP_UI_ITEM, 'About', None, self.about, 'about',
			 APP_PIXMAP_STOCK, STOCK_MENU_ABOUT, 0, 0)
		]
		menuinfo = [
			UIINFO_SUBTREE('Game', gameinfo),
			UIINFO_SUBTREE('Help', helpinfo)
		]
		tbinfo = gameinfo + helpinfo
		self.app.create_menus(menuinfo)
		self.app.create_toolbar(tbinfo)
		return	

	def new_game(self,i):
		su = StartUp()
		tmp = su.player_names()
		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 = GnomeAbout('Untee','0.2','GNU Public License', ['Vaibhav Vaish'],
						  'A Strategy Game from India')
		win.show()
	
	def not_yet(self,i):
		self.app.message('This feature is not supported\n in this version of Untee')
		return

	def create_contents(self):
		hbox = GtkHBox(FALSE,0)
		vbox = GtkVBox(FALSE,2)
		grid = GnomeCanvas()
		grid.set_usize(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 = GtkFrame("Players")
		vbx.pack_start(frame, FALSE, TRUE, 6)
		vb = GtkVBox(TRUE,2)
		frame.add(vb)

		for j in range(self.players):
			hbox = GtkHBox(FALSE,3)
			vb.pack_start(hbox, FALSE, TRUE, 2)
			
			pix = untee_pmaps.make_pixmap(self.pkeys[j])
			chk = untee_pmaps.make_pixmap('check')
			lab = GtkLabel(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 = GtkFrame("Move Panel")
		vbox.pack_start(frame, FALSE, FALSE, 2)
		hb = GtkHBox(TRUE,6)
		vb = GtkVBox(FALSE,6)
		frame.add(hb)
		hb.pack_start(vb,FALSE,TRUE,2)

		clist = GtkCList(1, ['Available Moves'])
		vb.pack_start(clist,TRUE,TRUE,2)
		clist.column_title_passive(0)
		clist.set_selection_mode(SELECTION_MULTIPLE)

		for j in range(4):
			clist.append([''])
			clist.set_selectable(j,0)

		roll = GtkButton('Roll')
		roll.connect('clicked',self.rolled)
		vb.pack_end(roll,FALSE,TRUE,2)
		self.clist = clist
		
		roll.show()
		clist.show()
		vb.show()
		hb.show()
		frame.show()

	# Methods for move management

	# Called when none of the available moves is valid.
	def failed_move(self):
		for j in range(self.clist.rows):
			self.clist.set_selectable(j,0)
		self.app.message('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.total()

		if curr == 0:
			self.app.error('You have no tokens in this box.')
			return
		if total == 0:
			self.app.error('You need to select at least one move.')
			return
		
		num,dest = self.get_number(sqr.index,total)
		if dest < 0:
			self.app.error('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 self.clist.rows == 1:
				self.clist.select_row(0,0)
		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)
			ch_index = fnum.index
			return choices[ch_index],dests[ch_index]
	
	# 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 + new_moves
		self.clist.freeze()
		for j in new_moves:
			self.clist.append([str(j)])
		self.clist.thaw()
	
	# Delete selected moves after move execution
	def del_selected(self):
		cl = self.clist
		sel = cl.selection
		sel.sort()
		num_sel = len(sel)
		
		if num_sel == cl.rows:
			cl.clear()
			self.available = []
		else:
			cl.freeze()
			for j in range(num_sel):
				index = sel[num_sel-j-1]
				cl.remove(index)
				self.available[index:index+1] = []
			cl.thaw()
		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 self.clist.rows == 1:
			self.clist.select_row(0,0)
		self.rollable = 0
		self.movable = 1
		return
		
	def roll_kaudis(self):
		def one_roll():
			kaudis = [0,0,0,0]
			sum=0
			for j in range(4):
				kaudis[j] = whrandom.randint(0,1)
				sum = sum+kaudis[j]
			if sum % 4 == 0:
				sum = sum+4
			return sum
		
		kd = one_roll()
		val = [ kd ]

		while (kd == 8 and len(val) < 3):
			kd = one_roll()
			val.append(kd)
		
		if (len(val) == 3 and val[2] == 8):
			return []
		else:
			return val

	def new_moves(self):
		moves = self.roll_kaudis()
		self.available = moves
		cl = self.clist
		sz = len(moves)

		cl.freeze()
		if cl.rows > 0:
			cl.clear()		# Only at startup

		for j in range(sz):
			cl.append([str(moves[j])])
		
		cl.thaw()
		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
			j = j+1

		return valid
	
	def total(self):
		sum = 0
		for j in self.clist.selection:
			sum = sum + self.available[j]
		return sum
	
	# 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 = GnomeOkDialog(msg)
		popup.run_and_close()
		return

a = Untee()
mainloop()
