Herramientas necesarias en Minecraft


In [ ]:
#Construccion de un bloque junto al jugador

import mcpi.minecraft as minecraft
mc = minecraft.Minecraft.create("192.168.1.3")

position = mc.player.getTilePos()
x = position.x
y = position.y
z = position.z

mc.setBlock(x,y+2,z,103)

In [ ]:
# Barra de lana multicolor

import time

import mcpi.minecraft as minecraft
mc = minecraft.Minecraft.create("192.168.1.3")

pos= mc.player.getTilePos()
x = pos.x
y = pos.y
z = pos.z

color = 0
lana = 35

while True:
    
    mc.setBlock(x+1, y, z, lana,color)
    time.sleep(0.2)
    mc.setBlock(x+2, y, z, lana,color)
    time.sleep(0.2)
    mc.setBlock(x+3, y, z, lana,color)
    time.sleep(0.2)
    mc.setBlock(x+4, y, z, lana,color)
    time.sleep(0.2)
    mc.setBlock(x+5, y, z, lana,color)
    time.sleep(0.2)
    mc.setBlock(x+6, y, z, lana,color)
    time.sleep(0.2)
    mc.setBlock(x+7, y, z, lana,color)
    time.sleep(0.2)
    mc.setBlock(x+8, y, z, lana,color)
    time.sleep(0.2)
    mc.setBlock(x+9, y, z, lana,color)
    time.sleep(0.2)
    mc.setBlock(x+10, y, z, lana,color)
    time.sleep(0.2)
    mc.setBlock(x+11, y, z, lana,color)
    time.sleep(0.2)
    mc.setBlock(x+12, y, z, lana,color)
    
    color = color + 1
    if color > 15:
        color = 0

In [ ]:
# Limpieza de un area determinada

# Get the player position
pos = mc.player.getTilePos()

# Ask the user how big a space to clear
size = int(raw_input("size of area to clear? "))

# Clear a space size by size*size*size, by setting it to AIR
mc.setBlocks(pos.x, pos.y , pos.z, pos.x+size, pos.y+size, pos.z+size,0)

Modulo conexion


In [ ]:
%%writefile conexionMinecraft.py

import mcpi.minecraft as minecraft


class Conexion:
    
    def __init__(self, ip):
        self.mc = minecraft.Minecraft.create(ip)

Modulo Bloque


In [ ]:
%%writefile bloqueConTweet.py

import mcpi.minecraft as minecraft
import math
import datetime

# Clase bloque

class Bloque:
    def __init__(self,conexion , x , y, z, info,fechaCreacion, tipo = 35, color = "blanco", visible = True ):
        self.mc = conexion.mc
        self.x = x
        self.y = y
        self.z = z
        self.fechaCreacion = fechaCreacion
        self.info = info
        self.tipo = tipo
        self.visible = visible
        self.color = self.dameCodigoColor(color)
      
    def __repr__(self):
        return "Bloque en %.1f %.1f %.1f con info %s"%( self.x, self.y, self.z, self.info)
        
    def dameCodigoColor(self, color):
        """ Esta funcion coge un color y te devuelve el codigo del bloque correspondiente de lana con ese color"""
    
        # Esto de abajo es un diccionario que se estructura en elementos de la forma llave:valor
        wool = {"blanco": 0, "naranja": 1, "purpura": 2, "azul": 3, "amarillo": 4, "verde": 5, "rosa": 6, "cacao": 7,
            "gris": 8, "turquesa": 9, "lila": 10, "azul oscuro": 11, "marron": 12, "verde oscuro": 13, 
            "rojo": 14,"negro": 15}
    
        return wool[color]
        
    def ponerBloque(self):
        self.mc.setBlock(self.x, self.y, self.z, self.tipo , self.color)
    
    def distancia(self, punto):
        xd = self.x - punto.x
        yd = self.y - punto.y
        zd = self.z - punto.z
        return math.sqrt((xd*xd) + (yd*yd) + (zd*zd))
    
    def muestraInfo(self):
        self.mc.postToChat(self.info)
        
    def haSidoGolpeado(self):
        hits = self.mc.events.pollBlockHits()
        for hit in hits:
            if hit.pos.x == self.x and hit.pos.y == self.y and hit.pos.z == self.z:
                return True
            
    def haSidoDestruido(self):
        if self.mc.getBlock(self.x, self.y, self.z) == 0: 
            return True

In [ ]:
position = mc.player.getTilePos()
x = position.x
y = position.y
z = position.z


bloques = []

b1 = Bloque(mc, x + 2, y, z, "Hola", color = "negro")
bloques.append(b1)
b2 = Bloque(mc, x + 5, y, z, "Adios", color = "rojo")
bloques.append(b2)

while True:
    for bloque in bloques:
        if bloque.haSidoGolpeado():
            bloque.muestraInfo()
        if bloque.haSidoDestruido():
            mc.postToChat("Un bloque ha sido destruido")

Campo de opinion


In [ ]:
import mcpi.minecraft as minecraft
mc = minecraft.Minecraft.create("192.168.1.38")

""" Coordenadas del campo:

(0,0,0)                       (16,0,0)                        (32,0,0)              x
   +------------------------------+------------------------------+              +-------> 
   |                              |                              |              |
   |                              |                              |            z |
   |                              |                              |              |
   |                              |                              |              |
   |                              |                              |              v
   |                              |                              |
   |                              |                              |
   +------------------------------+------------------------------+
(0,0,16)                     (16,0,16)                         (32,0,16)  
   
"""
size = 32

# Aclaramos el terreno
mc.setBlocks(-size*2, 0 , -size*2, size*2, size*2, size*2, 0)

# Ponemos el suelo
mc.setBlocks(0, -2 , 0, size, 0, size/2, 35,0)
mc.setBlocks(17, 0 ,0, size, 0, size/2, 35,7)

# Bordes del campo
mc.setBlocks(-1, 0 , -1, 0, -1, 16, 35,15)
mc.setBlocks(-1, 0 , -1, 32, 0, -1, 35,15)
mc.setBlocks( 0, -1 , 16, 32, 0, 16, 35,15)
mc.setBlocks( 32, 0 , -1, 32, 0, 16, 35,15)
mc.setBlocks( 16, 0 , -1, 16, 0, 16, 35,15)

# Teletrasportamos a Steve
mc.player.setTilePos(16, 1, 16)

In [1]:
#%%writefile campoOpinion.py

import mcpi.minecraft as minecraft
import conexionMinecraft as Conexion
import bloqueConTweet as Bloque
import math
import datetime
import time

class CampoOpinion:
    def __init__(self, conexion ,origenX, origenY, origenZ, largo, ancho, fechaInicio, fechaFinal, unidadesTiempo ):
        self.conexion = conexion
        self.origenX = origenX
        self.origenY = origenY
        self.origenZ = origenZ
        self.largo = largo
        self.ancho = ancho
        self.fechaInicio = fechaInicio
        self.fechaFinal = fechaFinal
        self.unidadesTiempo = unidadesTiempo
        self.tiempoParpadeo = 2 #segundos
        self.bloques = []
        
    def dibujarCampo(self):
        # Aclaramos el terreno
        self.conexion.mc.setBlocks(self.origenX-self.largo*2, self.origenY , self.origenZ-self.largo*2,\
                          self.origenX +self.largo*2, self.origenY + self.largo*2, self.origenY + self.largo*2, 0)

        # Ponemos el suelo
        self.conexion.mc.setBlocks(self.origenX, self.origenY-2 ,self.origenZ ,\
                          self.origenX+self.largo, self.origenY, self.origenZ+self.largo/2, 35,0)
        self.conexion.mc.setBlocks(self.origenX + 17, self.origenY ,self.origenZ, \
                          self.origenX +self.largo, self.origenY, self.origenZ+self.largo/2, 35,7)
        # Bordes del campo+
        self.conexion.mc.setBlocks(self.origenX-1, self.origenY , self.origenZ-1, self.origenX, self.origenY-1, self.origenZ+16, 35,15)
        self.conexion.mc.setBlocks(self.origenX-1, self.origenY , self.origenZ-1, self.origenX+32, self.origenY, self.origenZ-1, 35,15)
        self.conexion.mc.setBlocks( self.origenX, self.origenY-1 , self.origenZ+16, self.origenX+32, self.origenY, self.origenZ+16, 35,15)
        self.conexion.mc.setBlocks( self.origenX + 32, self.origenY , self.origenZ-1, self.origenX+32, self.origenY, self.origenZ+16, 35,15)
        self.conexion.mc.setBlocks( self.origenX + 16, self.origenY , self.origenZ-1, self.origenX+16, self.origenY, self.origenZ+16, 35,15)

        # Teletrasportamos a Steve
        self.conexion.mc.player.setTilePos(self.origenX+16, self.origenY+1, self.origenZ+16)
        
    def situarBloque(self, fechaBloque, creador,infoBloque,color, tipoBloque = 'positivo'):
        """ Da la coordenada x para situar el bloque en el campo de opinion segun la fecha de creacion del mismo
        Todos los bloques creados en el primer instante se situan en las coordenadas con origenX si tienen calificacion
        positiva y en origenX+largo si tienen clasificacion negativa, los que se crean
        un tiempo mas tarde se van situando en x que se van acercando al centro del campo
        La coordenada Z esta marcada por el creador del bloque, cada creador tiene una z asignada
        Los bloques del mismo creador , del mismo tipo y asignados a la misma x se apilan en el eje Y """
        
        if fechaBloque <= self.fechaInicio:
            return self.origenX
        if fechaBloque >= self.fechaFinal:
            return self.largo/2
        
        diferenciaInicialFinal = self.fechaFinal - self.fechaInicio
        diferenciaInicialBloque = fechaBloque - self.fechaInicio
        
        if self.unidadesTiempo == 'minutos':
            instanteDiferenciaInicialFinal = (diferenciaInicialFinal.seconds//60)%60
            instanteDiferenciaInicialBloque = (diferenciaInicialBloque.seconds//60)%60
        elif self.unidadesTiempo == 'horas':
            instanteDiferenciaInicialFinal = diferenciaInicialFinal.seconds//3600
            instanteDiferenciaInicialBloque = diferenciaInicialBloque.seconds//3600
        elif self.unidadesTiempo == 'dias':
            instanteDiferenciaInicialFinal = diferenciaInicialFinal.days
            instanteDiferenciaInicialBloque = diferenciaInicialBloque.days
            
        x = (instanteDiferenciaInicialBloque * self.largo/2)/instanteDiferenciaInicialFinal
        z = creador
        y = 1
        
        if tipoBloque != 'positivo':
            x , y, z = self.largo - x, y , z
         
        for bloque in self.bloques:
            if bloque.x == x and bloque.z == z:
                if bloque.y >= y:
                    y = bloque.y + 1
                    
        b = Bloque.Bloque(self.conexion, x, y, z,infoBloque,fechaBloque,color=color)
        b.ponerBloque()
        self.bloques.append(b)
        
    def vigilaCampo(self):
        while True:
            for bloque in self.bloques:
                
                # Los bloques recien puestos parpadean
                tiempoParpadeo = datetime.timedelta(seconds=self.tiempoParpadeo )
                ahora = datetime.datetime.now()
                #ahora = datetime.datetime(2003, 8, 4, 12, 56, 50)
                finParpadeo = bloque.fechaCreacion + tiempoParpadeo
                
                if ahora < finParpadeo:
                    if bloque.estado == 'parpadeo' and bloque.visible:
                        bloque.visible = False
                        conexion.mc.setBlock(bloque.x, bloque.y,bloque.z,0)
                    elif bloque.estado == 'parpadeo' and not bloque.visible:
                        bloque.visible = True
                        conexion.mc.setBlock(bloque.x, bloque.y,bloque.z,35,bloque.color)
                elif bloque.estado == 'parpadeo':
                    bloque.estado = 'sinParpadeo'
                    bloque.visible = True
                    conexion.mc.setBlock(bloque.x, bloque.y,bloque.z,35,bloque.color)
                
                # Sacando la info del bloque
                if bloque.haSidoGolpeado():
                    self.conexion.mc.postToChat(bloque.info)
                # Al destruir el bloque pasa de ser negativo a positivo y viceversa
                if conexion.mc.getBlock(bloque.x, bloque.y,bloque.z) == 0 and bloque.estado == 'sinParpadeo' :
                    if bloque.x < 16:
                        bloque.x = 16 + abs(16-bloque.x)
                    elif bloque.x > 16:
                        bloque.x = 16 - abs(16-bloque.x)
   
                    conexion.mc.setBlock(bloque.x, bloque.y,bloque.z,35,bloque.color)
    
        
        
            

""" Coordenadas del campo:

(0,0,0)                       (16,0,0)                        (32,0,0)              x
   +------------------------------+------------------------------+              +-------> 
   |                              |                              |              |
   |                              |                              |            z |
   |                              |                              |              |
   |                              |                              |              |
   |                              |                              |              v
   |                              |                              |
   |                              |                              |
   +------------------------------+------------------------------+
(0,0,16)                     (16,0,16)                         (32,0,16)  
   
"""

    
if __name__ == "__main__":
    conexion = Conexion.Conexion("192.168.1.38")

    intervaloTiempoCampo = datetime.timedelta(minutes = 16)
    fechaInicio = datetime.datetime.now()
    fechaFinal = fechaInicio  + intervaloTiempoCampo

    #(self, conexion ,origenX, origenY, origenZ, largo, ancho, fechaInicio, fechaFinal, unidades )
    campo = CampoOpinion(conexion, 0,0,0,32,16,fechaInicio,fechaFinal,'minutos')
    campo.dibujarCampo()
    #situarBloque(self, fechaBloque, creador,infoBloque,color, tipoBloque = 'positivo')
    fechaBloque1 = datetime.datetime.now()
    campo.situarBloque(fechaBloque1, 8, "1","rojo", 'negativo')
    time.sleep(5)
    fechaBloque2 = datetime.datetime.now()
    campo.situarBloque(fechaBloque2, 8, "2","azul", 'negativo')
    time.sleep(5)
    fechaBloque3 = datetime.datetime.now() 
    campo.situarBloque(fechaBloque3, 8, "3","verde", 'negativo')
    time.sleep(5)
    fechaBloque4 = datetime.datetime.now()
    campo.situarBloque(fechaBloque4, 8, "4","rojo", 'negativo')
    
    campo.vigilaCampo()


Overwriting campoOpinion.py

Detectando el bloque mas cercano en el campo de opinion


In [ ]:
import mcpi.minecraft as minecraft
import bloqueConTweet as Bloque
import conexionMinecraft as Conexion
import math
import time

conexion = Conexion.Conexion("192.168.1.38")

bloques = []

b1 = Bloque.Bloque(conexion, 8, 1, 8, "Hola", color = "azul")
bloques.append(b1)
b2 = Bloque.Bloque(conexion,10, 1, 14, "Adios", color = "rojo")
bloques.append(b2)
b3 = Bloque.Bloque(conexion,14, 1, 14, "que tal", color = "amarillo")
bloques.append(b3)


distanciaMinParaDeteccion = 3
distanciaBloqueMasCercano =  1000
bloqueMasCercanoAJugador = None

while True:

    # Tomo la posicion del jugador
    posicionJugador = conexion.mc.player.getTilePos()
    
    for bloque in bloques:
        distanciaBloqueAJugador = bloque.distancia(posicionJugador)
        print(distanciaBloqueAJugador)
        if  distanciaBloqueAJugador < distanciaMinParaDeteccion and distanciaBloqueAJugador < distanciaBloqueMasCercano :
            bloque.muestraInfo()
            distanciaBloqueMasCercano = distanciaBloqueAJugador
            bloqueMasCercanoAJugador = bloque
            
    if bloqueMasCercanoAJugador != None:
        bloqueMasCercanoAJugador.muestraInfo()
        distanciaBloqueMasCercano =  1000
        bloqueMasCercanoAJugador = None

Gestor de bloques


In [ ]:
import mcpi.minecraft as minecraft
import bloqueConTweet as Bloque
import conexionMinecraft as Conexion
import math
import time
import datetime

conexion = Conexion.Conexion("192.168.1.38")

bloques = []

b1 = Bloque.Bloque(conexion, 8, 1, 8, "Hola", color = "azul", datetime.datetime(2003, 8, 4, 21, 41, 43))
bloques.append(b1)
b2 = Bloque.Bloque(conexion,10, 1, 14, "Adios", color = "rojo", datetime.datetime(2003, 8, 4, 21, 41, 43))
bloques.append(b2)
b3 = Bloque.Bloque(conexion,14, 1, 14, "que tal", color = "amarillo", datetime.datetime(2003, 8, 4, 21, 41, 43))
bloques.append(b3)
# the default formatting for a datetime object is an ISO 8601-style string: “yyyy-mm-dd hh:mm:ss”


distanciaMinParaDeteccion = 3
distanciaBloqueMasCercano =  1000
bloqueMasCercanoAJugador = None

while True:

    # Tomo la posicion del jugador
    posicionJugador = conexion.mc.player.getTilePos()
    
    for bloque in bloques:
        #Compruebo que el bloque existe en su posicion original, y si no existe lo pongo en la otra zona del campo
        if conexion.mc.getBlock(bloque.x, bloque.y,bloque.z) == 0:
            if bloque.x < 16:
                bloque.x = 16 + abs(16-bloque.x)
            elif bloque.x > 16:
                bloque.x = 16 - abs(16-bloque.x)
   
            conexion.mc.setBlock(bloque.x, bloque.y,bloque.z,35,bloque.color)
            
        distanciaBloqueAJugador = bloque.distancia(posicionJugador)
        
        if  distanciaBloqueAJugador < distanciaMinParaDeteccion and distanciaBloqueAJugador < distanciaBloqueMasCercano :
            bloque.muestraInfo()
            distanciaBloqueMasCercano = distanciaBloqueAJugador
            bloqueMasCercanoAJugador = bloque
            
    if bloqueMasCercanoAJugador != None:
        bloqueMasCercanoAJugador.muestraInfo()
        distanciaBloqueMasCercano =  1000
        bloqueMasCercanoAJugador = None

In [ ]:


In [ ]:


In [ ]: