tp3_objetos.py

import random

class _Pila:
	def __init__(self):
		self.elementos=[]

	def apilar (self,dato):
		self.elementos.append(dato)

	def obtener_tope(self):
		return self.elementos[-1]

	def desapilar(self):
		return self.elementos.pop()

	def esta_vacia(self):
		return len(self.elementos)==0


class _Nodo:
	def __init__(self,dato,prox=None,ant=None):
		self.dato=dato
		self.prox=prox
		self.ant=ant


class _ListaDoblementeEnlazadaCircular:
	"""Representa una mesa donde dentro de cada nodo hay un jugador"""
	def __init__(self):
		"""Constructor de clase _lista doblemente enlazada circular"""
		self.prim=None
		self.nodo_actual=None
		self.len=0

	def append(self,dato):
		"""Agrega un nodo"""
		nodo=_Nodo(dato)
		if self.len==0:
			nodo.prox=nodo
			nodo.ant=nodo
			self.prim=nodo
			self.nodo_actual=self.prim
		else:
			nodo.prox=self.prim
			nodo.ant=self.prim.ant
			nodo.ant.prox=nodo
			self.prim.ant=nodo
		self.len+=1

	def obtener_proximo(self):
		if self.len==0:
			return None
		nodo_actual=self.nodo_actual
		nodo_proximo=nodo_actual.prox
		self.nodo_actual=nodo_proximo #ahora el actual es el siguiente
		return nodo_proximo.dato

	def obtener_anterior(self): #para cuando el sentido se invierte
		if self.len==0:
			return None
		nodo_actual=self.nodo_actual
		nodo_anterior=nodo_actual.ant
		self.nodo_actual=nodo_anterior
		return nodo_anterior.dato

	def obtener_actual(self):
		if self.len==0:
			return None
		return self.nodo_actual.dato

	def __len__(self):
		return self.len


class _Mazo:
	"""Representa a un mazo de cartas"""
	def __init__(self):
		"""constructor de la clase _Mazo"""
		self.cartas_en_mazo=_Pila()
		self.len=0

	def __len__(self):
		return self.len

	def agregar_carta(self,carta):
		"""Agrega una carta al mazo"""
		self.cartas_en_mazo.apilar(carta)
		self.len+=1

	def dar_carta(self,otro=None): #otro es el mazo_auxiliar
		"""Devuelve la primer carta del mazo al jugador"""
		return self.cartas_en_mazo.desapilar()
		self.len-=1

	def mezclar(self):
		"""Cambia de posición de manera aleatoria las cartas que están en el mazo a traves de un cambio de lista a pila, pila a lista """
		cant_de_cartas=self.len
		lista=pila_a_lista(self.cartas_en_mazo)
		for i in range(cant_de_cartas):
			variante= random.randrange(i,cant_de_cartas)
			lista[i],lista[variante] = lista[variante],lista[i]
		self.cartas_en_mazo = lista_a_pila(lista)

	def esta_vacio(self):
		return self.cartas_en_mazo.esta_vacia()

	def mostrar_carta_de_arriba(self):
		"""Devuelve la representacion de la primer carta del mazo"""
		return str(self.ver_tope())

	def ver_tope(self):
		"""Devuelve la carta que se encuentra arriba del mazo pero no la saca"""
		carta_arriba=self.cartas_en_mazo.desapilar()
		self.cartas_en_mazo.apilar(carta_arriba)
		return carta_arriba

	def llenar(self,COLORES_CARTAS):
		"""Llena el mazo con todas las cartas del uno"""
		for color in COLORES_CARTAS: #agregar los números
			for numero in range(1,VALOR_NUMERICO_MAXIMO+1):
				for veces in range(CANT_CARTAS_POR_COLOR):
					self.cartas_en_mazo.apilar(_CartaUno(numero,"None",color))
					self.len+=1
			self.cartas_en_mazo.apilar(_CartaUno(0,"None",color))
			self.len+=1
			for veces in range(CANT_CARTAS_POR_COLOR): #agregar las cartas especiales
				for accion in CARTAS_ESPECIALES_CON_COLOR: #porque agrega dos de cada una
					self.cartas_en_mazo.apilar(_CartaUno("None",accion,color))
					self.len+=1
			for accion in CARTAS_ESPECIALES_SIN_COLOR:
				self.cartas_en_mazo.apilar(_CartaUno("None",accion,"Sin color"))
				self.len+=1