Mundos del Videojuego

Virtuix Omni

2014-08-08T14:01:00.000+02:00

¿Os acordáis de Oculus Rift? Que por cierto, pertenece a facebook ahora por su compra.

Pues aquí un complemento ideal, el Virtuix Omni. Hay otro similar por ahí cuyo nombre no me acuerdo. Son tecnologías que ya llevan rulando tiempo, a ver para cuando se convierte en una realidad más tangible.

Os dejo el enlace a su web y un vídeo, y a dejar volar la imaginación como lo he hecho yo. Ojalá termine de desarrollarse estas tecnologías...

Virtuix Omni

Día 198

2014-08-08T14:00:00.000+02:00

Y retomamos esto después de otra parada, en la que no he avanzado, e incluso retrocedido en el camino de entre los mundos del videojuego. Pero con la experiencia y el error se aprende, y coursera es buen sitio y se aprenden cosas aunque gasta un tiempo que debería haber usado para recorrer estos mundos. Es por ello, que dejaré coursera de lado.

En este tiempo he estado programando proyectos, y mi velocidad y experiencia crece, me siento más capaz y veo cómo mi visión y análisis de los juegos evoluciona, entrando en un mundo que no conocía, el de jugar cooperativamente online en un juego de supervivencia y muchos tiros.

Y me ha gustado mucho el sentimiento de ayuda entre todos, de forma desinteresada con un objetivo común y sin conocernos. Es un mundo mucho más rico del que pensaba. (y si, era Left 4 dead 2 el que probé).

Del diccionario también nos llegan nuevas palabras:

NDA
Acrónimo del término inglés Non-Disclosure Agreement (Acuerdo de Confidencialidad).

Contrato legal que firman los desarrolladores y/o los medios de prensa y que les impide hacer pública la información que las compañías consideran secreto profesional. Esto incluye tanto los propios proyectos de las desarrolladoras (un trabajador no puede hablar de un juego si la desarrolladora no ha hecho público su desarrollo o ciertas características del proyecto) como información confidencial fruto de relaciones entre diferencias entre compañías (documentos de desarrollo de las consolas, documentación y/o código de middleware, código accesible vía contrato de outsourcing donde la empresa contratada accede al código del juego de la empresa contratante, etc).
(Industria, Prensa)

Demake
Del inglés de-make (deshacer) como opuesto a re-make (rehacer).

Adaptación de un videojuego moderno a una plataforma antigua.
No se realiza de manera comercial, sino que es una tendencia surgida entre la comunidad de jugadores retro, que los realizan de manera desinteresada como oposición a los remakes, que adaptan juegos antiguos a nuevas plataformas.
(Cultura gamer, Reediciones)
Términos relacionados: Remake, Retro

Mid-core Gamer
Del inglés Mid-core Gamer (Jugador intermedio).

Perfil de jugador que se sitúa a medio camino entre un Casual Gamer y un Hardcore Gamer. Se caracteriza por preferir juegos que poseen la accesibilidad y las mecánicas jugables sencillas propias de los juegos casual pero acompañadas por los valores de producción, profundidad e inmersión de los juegos hardcore.
Por lo general se trata de un jugador con gran dedicación e interés por los videojuegos, como los hardcore gamers, pero que por falta de tiempo o aburrimiento ha dejado de prestar atención a los juegos propios de los hardcore.
(Jugadores, Perfiles Gamers)
Términos relacionados: Casual Gamer, Hardcore Gamer

Uy, este último parece que encaja conmigo, ¡¡soy un Mid-core gamer!!

RiceRocks en python

2014-08-07T14:02:00.000+02:00

Juego de asteroids en python.

Con las teclas de dirección para moverse y el espacio para disparar es todo lo que necesitas para jugar.

No es gran cosa, pero aún así ayuda en mi viaje ya que lo mejor de este código es haber aprendido cómo manejar las animaciones, su dibujado y su relación con el tiempo, aunque no nos hallamos metido con los conceptos de fps (frames per second/frames por segundo)

Una vez más, toca ejecutarlo en CodeSkulptor por la librería gráfica propia de la plataforma.

RiceRocks: Pulsa para ver/ocultar el código

import simplegui
import math
import random

# globals for user interface
WIDTH = 800
HEIGHT = 600
score = 0
lives = 3
time = 0
started = False
limit_rocks=12

class ImageInfo:
    def __init__(self, center, size, radius = 0, lifespan = None, animated = False):
        self.center = center
        self.size = size
        self.radius = radius
        if lifespan:
            self.lifespan = lifespan
        else:
            self.lifespan = float('inf')
        self.animated = animated

    def get_center(self):
        return self.center

    def get_size(self):
        return self.size

    def get_radius(self):
        return self.radius

    def get_lifespan(self):
        return self.lifespan

    def get_animated(self):
        return self.animated

    
# art assets created by Kim Lathrop, may be freely re-used in non-commercial projects, please credit Kim
    
# debris images - debris1_brown.png, debris2_brown.png, debris3_brown.png, debris4_brown.png
#                 debris1_blue.png, debris2_blue.png, debris3_blue.png, debris4_blue.png, debris_blend.png
debris_info = ImageInfo([320, 240], [640, 480])
debris_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/debris2_blue.png")

# nebula images - nebula_brown.png, nebula_blue.png
nebula_info = ImageInfo([400, 300], [800, 600])
nebula_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/nebula_blue.f2013.png")

# splash image
splash_info = ImageInfo([200, 150], [400, 300])
splash_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/splash.png")

# ship image
ship_info = ImageInfo([45, 45], [90, 90], 35)
ship_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/double_ship.png")

# missile image - shot1.png, shot2.png, shot3.png
missile_info = ImageInfo([5,5], [10, 10], 3, 50)
missile_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/shot2.png")

# asteroid images - asteroid_blue.png, asteroid_brown.png, asteroid_blend.png
asteroid_info = ImageInfo([45, 45], [90, 90], 40)
asteroid_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/asteroid_blue.png")

# animated explosion - explosion_orange.png, explosion_blue.png, explosion_blue2.png, explosion_alpha.png
explosion_info = ImageInfo([64, 64], [128, 128], 17, 24, True)
explosion_image = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/lathrop/explosion_alpha.png")

# sound assets purchased from sounddogs.com, please do not redistribute
# .ogg versions of sounds are also available, just replace .mp3 by .ogg
soundtrack = simplegui.load_sound("http://commondatastorage.googleapis.com/codeskulptor-assets/sounddogs/soundtrack.mp3")
missile_sound = simplegui.load_sound("http://commondatastorage.googleapis.com/codeskulptor-assets/sounddogs/missile.mp3")
missile_sound.set_volume(.5)
ship_thrust_sound = simplegui.load_sound("http://commondatastorage.googleapis.com/codeskulptor-assets/sounddogs/thrust.mp3")
explosion_sound = simplegui.load_sound("http://commondatastorage.googleapis.com/codeskulptor-assets/sounddogs/explosion.mp3")

# helper functions to handle transformations
def angle_to_vector(ang):
    return [math.cos(ang), math.sin(ang)]

def dist(p, q):
    return math.sqrt((p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2)


# Ship class
class Ship:

    def __init__(self, pos, vel, angle, image, info):
        self.pos = [pos[0], pos[1]]
        self.vel = [vel[0], vel[1]]
        self.thrust = False
        self.angle = angle
        self.angle_vel = 0
        self.image = image
        self.image_center = info.get_center()
        self.image_size = info.get_size()
        self.radius = info.get_radius()
        
    def get_position(self):
        return self.pos
    
    def get_radius(self):
        return self.radius
        
    def draw(self,canvas):
        if self.thrust:
            canvas.draw_image(self.image, [self.image_center[0] + self.image_size[0], self.image_center[1]] , self.image_size,
                              self.pos, self.image_size, self.angle)
        else:
            canvas.draw_image(self.image, self.image_center, self.image_size,
                              self.pos, self.image_size, self.angle)
        # canvas.draw_circle(self.pos, self.radius, 1, "White", "White")

    def update(self):
        # update angle
        self.angle += self.angle_vel
        
        # update position
        self.pos[0] = (self.pos[0] + self.vel[0]) % WIDTH
        self.pos[1] = (self.pos[1] + self.vel[1]) % HEIGHT

        # update velocity
        if self.thrust:
            acc = angle_to_vector(self.angle)
            self.vel[0] += acc[0] * .1
            self.vel[1] += acc[1] * .1
            
        self.vel[0] *= .99
        self.vel[1] *= .99

    def set_thrust(self, on):
        self.thrust = on
        if on:
            ship_thrust_sound.rewind()
            ship_thrust_sound.play()
        else:
            ship_thrust_sound.pause()
       
    def increment_angle_vel(self):
        self.angle_vel += .05
        
    def decrement_angle_vel(self):
        self.angle_vel -= .05
        
    def shoot(self):
        forward = angle_to_vector(self.angle)
        missile_pos = [self.pos[0] + self.radius * forward[0], self.pos[1] + self.radius * forward[1]]
        missile_vel = [self.vel[0] + 6 * forward[0], self.vel[1] + 6 * forward[1]]
        a_missile = Sprite(missile_pos, missile_vel, self.angle, 0, missile_image, missile_info, missile_sound)
        missiles.add(a_missile)
    
    
# Sprite class
class Sprite:
    def __init__(self, pos, vel, ang, ang_vel, image, info, sound = None):
        self.pos = [pos[0],pos[1]]
        self.vel = [vel[0],vel[1]]
        self.angle = ang
        self.angle_vel = ang_vel
        self.image = image
        self.image_center = info.get_center()
        self.image_size = info.get_size()
        self.radius = info.get_radius()
        self.lifespan = info.get_lifespan()
        self.animated = info.get_animated()
        self.age = 0
        if sound:
            sound.rewind()
            sound.play()
   
    def draw(self, canvas):
        canvas.draw_image(self.image, self.image_center, self.image_size,
                          self.pos, self.image_size, self.angle)

    def get_position(self):
        return self.pos
    
    def get_radius(self):
        return self.radius
        
    def update(self):
        # update angle
        self.angle += self.angle_vel
        
        # update position
        self.pos[0] = (self.pos[0] + self.vel[0]) % WIDTH
        self.pos[1] = (self.pos[1] + self.vel[1]) % HEIGHT
        
        if self.lifespan!=None:
            self.age=self.age+1
            if self.age>self.lifespan:
                return True
            else:
                return False
        
    def collide(self, other_sprite):
        other_pos = other_sprite.get_position()
        other_rad = other_sprite.get_radius()        
        if dist(self.pos, other_pos) < (other_rad + self.radius):
            return True
        else:
            return False

  
        
# key handlers to control ship   
def keydown(key):
    if key == simplegui.KEY_MAP['left']:
        my_ship.decrement_angle_vel()
    elif key == simplegui.KEY_MAP['right']:
        my_ship.increment_angle_vel()
    elif key == simplegui.KEY_MAP['up']:
        my_ship.set_thrust(True)
    elif key == simplegui.KEY_MAP['space']:
        my_ship.shoot()
        
def keyup(key):
    if key == simplegui.KEY_MAP['left']:
        my_ship.increment_angle_vel()
    elif key == simplegui.KEY_MAP['right']:
        my_ship.decrement_angle_vel()
    elif key == simplegui.KEY_MAP['up']:
        my_ship.set_thrust(False)
        
# mouseclick handlers that reset UI and conditions whether splash image is drawn
def click(pos):
    global started, timer
    center = [WIDTH / 2, HEIGHT / 2]
    size = splash_info.get_size()
    inwidth = (center[0] - size[0] / 2) < pos[0] < (center[0] + size[0] / 2)
    inheight = (center[1] - size[1] / 2) < pos[1] < (center[1] + size[1] / 2)
    if (not started) and inwidth and inheight:
        started = True
        timer.start()
        soundtrack.rewind()
        soundtrack.play()

def draw(canvas):
    global time, started, lives, score
    
    # animiate background
    time += 1
    wtime = (time / 4) % WIDTH
    center = debris_info.get_center()
    size = debris_info.get_size()
    canvas.draw_image(nebula_image, nebula_info.get_center(), nebula_info.get_size(), [WIDTH / 2, HEIGHT / 2], [WIDTH, HEIGHT])
    canvas.draw_image(debris_image, center, size, (wtime - WIDTH / 2, HEIGHT / 2), (WIDTH, HEIGHT))
    canvas.draw_image(debris_image, center, size, (wtime + WIDTH / 2, HEIGHT / 2), (WIDTH, HEIGHT))

    if started:
        #if touched
        if collide_group(rocks, my_ship):
            lives=lives-1
            
        if lives==0:
            reset_game()

        number_hits=collide_two_group(rocks, missiles)
        score=score+number_hits*10


    # draw ship and sprites
    my_ship.draw(canvas)
    draw_set(rocks, canvas)
    draw_set(missiles, canvas)
    
    # update ship and sprites
    my_ship.update()
    
    # draw UI
    canvas.draw_text("Lives", [50, 50], 22, "White")
    canvas.draw_text("Score", [680, 50], 22, "White")
    canvas.draw_text(str(lives), [50, 80], 22, "White")
    canvas.draw_text(str(score), [680, 80], 22, "White")

    # draw splash screen if not started
    if not started:
        canvas.draw_image(splash_image, splash_info.get_center(), 
                          splash_info.get_size(), [WIDTH / 2, HEIGHT / 2], 
                          splash_info.get_size())

def draw_set(the_set, canvas):
    for element in list(the_set):
        element.draw(canvas)
        if element.update():
            the_set.remove(element)
        
# timer handler that spawns a rock    
def rock_spawner():
    global limit_rocks
    if limit_rocks>len(rocks) :
        
        rock_pos = [random.randrange(0, WIDTH), random.randrange(0, HEIGHT)]
        rock_vel = [random.random() * .6 - .3, random.random() * .6 - .3]
        rock_avel = random.random() * .2 - .1
        new_rock = Sprite(rock_pos, rock_vel, 0, rock_avel, asteroid_image, asteroid_info)
        if new_rock.collide(my_ship):
            rock_spawner()
        else:
            rocks.add(new_rock)
    
    
def collide_group(the_set, element):
    for one_of_set in list(the_set):
        if one_of_set.collide(element):
            the_set.remove(one_of_set)
            return True
    return False
    
def collide_two_group(rock, missil):
    count_collide=0
    for one_rock in list(rock):
        for a_missil in list(missil):
            if one_rock.collide(a_missil):
                count_collide=count_collide+1
                missil.remove(a_missil)
                rock.remove(one_rock)
    return count_collide                

def reset_game():
    global lives, score,started, timer, number_rocks, rocks
    started=False
    number_rocks=0
    lives=3
    score=0
    rocks=set([])
    timer.stop()
    soundtrack.pause()
        
        
# initialize stuff
frame = simplegui.create_frame("Asteroids", WIDTH, HEIGHT)

# initialize ship and two sprites
my_ship = Ship([WIDTH / 2, HEIGHT / 2], [0, 0], 0, ship_image, ship_info)
rocks=set([])
missiles=set([])

# register handlers
frame.set_keyup_handler(keyup)
frame.set_keydown_handler(keydown)
frame.set_mouseclick_handler(click)
frame.set_draw_handler(draw)

timer = simplegui.create_timer(1000.0, rock_spawner)

# get things rolling
frame.start()

Los 13 principios de Glee

2014-08-07T14:01:00.000+02:00

De un majo hombre llamado James Paul Gee, un profesor de la universidad de Arizona, nos da unos trece principios sobre el aprendizaje en los videojuegos. Se parte de la idea de que el aprendizaje es en base a problemas.

Principio del co-diseñador: El jugador debe sentir que lo que hace importa, es importante, ya que lo que haces, afecta al juego y también los resultados y cómo resuelves los problemas en el juego.
Principio de la compresión como acción. La gente al aprender, asocian la palabra con una imagen, acción o experiencia. Eso se consigue si tienes algo más que palabras, si tienes experiencias, estás en el mundo (aunque sea simulado), no sirve simples definiciones o textos.

Principio del arenero. Llamado así por la analogía de un terrario de arena donde los crios juegan, exploran, prueban cosas, experimentan... estando en un entorno protegido (o con riesgos bajos) y sin ser juzgados, rankeados o similar. Un ejemplo podría ser los Sims.
Principio de la personalización. Los jugadores necesitan sentir que lo que hacen tiene sentido e importa. Lo que vendría a ser permitir diferentes tipos de jugadores, permitiendo ser lo que más les guste e incluso probar diferentes formas, estrategias, ser otro tipo de jugador distinto.
Principio del tanque de peces. Si se tienen buenos problemas y difíciles, se tendrá complejidad. Si nos fijamos en el ecosistema, serán demasiadas cosas y demasiada complejidad para poder abarcarlo. Si vamos sacando cosas hacia una pecera, podemos ir viendo paso por paso como reaccionan e interactúan los elementos y poder ir añadiendo complejidad. En los juegos viene a ser los niveles de los personajes, en los que se va añadiendo dificultad o nuevas cosas.
Principio de identidad. El principio del aprendizaje es saber en qué te vas a convertir y qué vas a conseguir si haces determinadas cosas y aprendes esas cosas. El jugador necesita saber porqué estás haciendo lo que haces, por ello el juego da un avatar, metas claras, y un claro sentimiento de quién eres/quién vas a ser.
Principio de la frustración gratificante. Tan sencillo como que un buen problema significa que lo ves como un desafío, que te frustra un poco conseguirlo pero sabes que vas a conseguir una forma de resolverlo.
Principio de la manipulación. La capacidad de manipulación del jugador en el juego, como es controlar al personaje.
Principio de los problemas bien ordenados. Se entiende rápido cuando pensamos en tutoriales o en el juego en general, en el que empiezas resolviendo problemas sencillos, cuyo aprendizaje sirve luego para problemas más grandes y complejos. El orden importa.
Principio en el momento y en demanda. Refiriéndose a en el momento a pequeñas piezas de información que puedes aplicar en el momento/lugar, mientras que en demanda se refiere más a las ayudas e informaciones más grandes de cuando te atascas y necesitas información, o simplemente quieres saber más, momento en el que estás preparado para recibir grandes cantidades de información.
Principio del pensamiento sistemático. El jugador intenta hacerse un modelo de cómo el sistema (juego) funciona, sus reglas, variables y complejidad, para poder saber que puede y puede no hacer.
Habilidades como estrategias. Un simple ejemplo, si en el juego eres un guerrero y estás simplemente pegando mandobles a cuatro gallinas, no tienes ni idea de qué haces, pero si sabes que tienes que matar a un gigante para conseguir la meta propuesta, la cosa cambia, ya que sabes que practicas los mandobles para conseguir dicha habilidad, siendo esa habilidad una estrategia para conseguir la meta.
Principio del ciclo del experto, se da un problema al jugador, éste lo practica y con ello consigue un conocimiento y una práctica con la que se convierte en maestro y resuelve el problema sin dificultad, hasta que se le ofrece otro problema con el que no sirve dicho conocimiento y vuelta a empezar.

Estos principios los he sacado del cursillo de Videojuegos y aprendizaje en Coursera. Si os digo la verdad, ya van como cuatro veces que me veo los vídeos y trato de entender lo que quiere decir, y todavía no lo he conseguido. Y se nota en que esto no deja de ser una cutre traducción del inglés en el que muchas cosas no sabía ni cómo traducirlo.

Si alguien quiere dar su opinión sobre lo que quiere decir o lo que opina que serían mejor otros principios. ¡Adelante y comenta!

Día 124

2014-08-07T14:00:00.000+02:00

Parece que veo el final del túnel, acabando ya con coursera, el cual me pensaré muy bien que siguientes cursos tomar, y compaginando con la universidad.

Debería empezar a tener algo más de tiempo para dedicar al viaje y salir de la maldita posada donde me quedé atascado, atendiendo los problemas de Deimos y Lyria, y cumpliendo con mis obligaciones.

Por cierto, Deimos y Lyria están perfectamente sanos y bastante protegidos, aunque miro de arroparlos un poco más por si acaso.

Y nos vamos a unos términos más para culturizarnos:

Pixel hunt
Del inglés pixel hunt (caza del píxel).

Recorrer "pixel a pixel" la pantalla para encontrar un objeto con el que interactuar.
Es común en juegos de aventura point and click, donde los jugadores atascados en una situación en la que es difícil saber con qué partes del escenario del juego se puede interactuar, responden a menudo haciendo clic metódicamente por toda la pantalla hasta que encuentran algo.
(En juego, Acciones)
Términos relacionados: Pixel

Tryhard
Del inglés try hard (esforzarse).

Jugador perfeccionista que invierte una gran cantidad de esfuerzo y concentración en llevar a cabo una estrategia en la partida para ganar y que sufre si no sale todo de acuerdo a su plan.
Suelen ser criticados porque pueden llegar a ser bastante molestos al centrarse demasiado en obtener la victoria en lugar de en divertirse.
(Jugadores, League of Legends)

PTFO
Del inglés "Play The Fucking Objective" (Juega al Puto Objetivo).

Expresión popularizada dentro del multijugador del juego Battlefield, y que usan algunos jugadores con sus compañeros de equipo cuando estos se centran más en matar enemigos que en cumplir el objetivo de la partida.
(Expresiones, juegos de Disparos, Battlefield)

Por los ojos entra

2014-08-06T14:07:00.000+02:00

Me he dado cuenta que mucho escribir por aquí, pero las cosas apenas se me quedan en la cabeza. ¿Alguien se acuerda ya del documento de diseño?

Yo no, y no debería. No he gastado tiempo en ello para después olvidarlo y como si no hubiera hecho nada. Pero tengo una pequeña solución. Verlo todos los días, tenerlo siempre presente.

Y es por eso que he cogido partes de lo que había escrito en el blog, lo he pasado a papel, y lo he colgado en la pared, delante mío. Todos los días estoy a la mesa, al ordenador, y todos los días lo miro y me acuerdo. Cada vez que abro un proyecto nuevo, un simple vistazo me recuerda la organización. Cada vez que veo un juego y hago un pequeño análisis, veo el documento de diseño y recuerdo todas las partes.

Y si, me equivoqué al escribir python.

Blackjack en python

2014-08-06T14:01:00.000+02:00

Un mini, pero que mini (como todo hasta ahora) juego de Blackjack, sacado del ya conocido curso de coursera.

Las reglas son sencillas: las cartas J,Q y K valen diez puntos, los ases 10 o 1, y el resto por su número de carta. Tienes que intentar tener más puntos que el otro, sin pasarse de 21. De forma que puedes escoger que te de más cartas para tener más puntos, o quedarte con las que tienes.

Una vez más, toca ejecutarlo en CodeSkulptor por la librería gráfica propia de la plataforma.

Blackjack: Pulsa para ver/ocultar el código

# Mini-project #6 - Blackjack

import simplegui
import random

# load card sprite - 949x392 - source: jfitz.com
CARD_SIZE = (73, 98)
CARD_CENTER = (36.5, 49)
card_images = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/cards.jfitz.png")

CARD_BACK_SIZE = (71, 96)
CARD_BACK_CENTER = (35.5, 48)
card_back = simplegui.load_image("http://commondatastorage.googleapis.com/codeskulptor-assets/card_back.png")    

# initialize some useful global variables
in_play = False
outcome = ""
score_dealer = 0
score_player = 0
the_deck =""
dealer_hand=""
my_hand=""

# define globals for cards
SUITS = ('C', 'S', 'H', 'D')
RANKS = ('A', '2', '3', '4', '5', '6', '7', '8', '9', 'T', 'J', 'Q', 'K')
VALUES = {'A':1, '2':2, '3':3, '4':4, '5':5, '6':6, '7':7, '8':8, '9':9, 'T':10, 'J':10, 'Q':10, 'K':10}


# define card class
class Card:
    def __init__(self, suit, rank):
        if (suit in SUITS) and (rank in RANKS):
            self.suit = suit
            self.rank = rank
        else:
            self.suit = None
            self.rank = None
            print "Invalid card: ", suit, rank

    def __str__(self):
        return self.suit + self.rank

    def get_suit(self):
        return self.suit

    def get_rank(self):
        return self.rank

    def draw(self, canvas, pos):
        card_loc = (CARD_CENTER[0] + CARD_SIZE[0] * RANKS.index(self.rank), 
                    CARD_CENTER[1] + CARD_SIZE[1] * SUITS.index(self.suit))
        canvas.draw_image(card_images, card_loc, CARD_SIZE, [pos[0] + CARD_CENTER[0], pos[1] + CARD_CENTER[1]], CARD_SIZE)
        
# define hand class
class Hand:
    def __init__(self):
        #list of cards of the hand
        self.cards=[]
        # value of the hand
        self.hand_value=0
        #has hand an ace?
        self.has_ace = False

    # return a string representation of a hand
    def __str__(self):
        result="Hand contains "
        #for every card...
        for next in self.cards:
            result=result + " " + str(next)
        return result

    def add_card(self, card):
        # add a card object to a hand
        self.cards.append(card)
        #sum the value of the card
        self.hand_value=self.hand_value+VALUES[card.get_rank()]
        
        #check if i have an ace
        if card.get_rank() == RANKS[0]:
            self.has_ace=True

    def get_value(self):
        # count aces as 1, if the hand has an ace, then add 10 to hand value if it doesn't bust
        if self.has_ace == True:
            if self.hand_value+10 <=21:
                return self.hand_value+10
        return self.hand_value
   
    def draw(self, canvas, pos):
        i=0
        #for every card...
        for next in self.cards:
            card_pos=((i * CARD_SIZE[0])+pos[0]+10*i, pos[1])
            next.draw(canvas, card_pos)
            i=i+1 #increase the position of the card
        
# define deck class 
class Deck:
    def __init__(self):
        #list of cards
        self.cards=[]
        #double for, every cards
        for rank in RANKS:
            for suit in SUITS:
                self.cards.append(Card(suit, rank))
                
    #remix the cards
    def shuffle(self):
        # shuffle the deck
        random.shuffle(self.cards)

    def deal_card(self):
        return self.cards.pop()
    
    def __str__(self):
        result="Deck contains "
        #for every card...
        for next in self.cards:
            result=result + " " + str(next)
        return result


#define event handlers for buttons
def deal():
    global outcome, in_play, the_deck, dealer_hand, my_hand, score_dealer
    #reset the outcome
    outcome=""
    #reset the deck and hands
    the_deck=Deck()
    the_deck.shuffle()
    dealer_hand=Hand()
    my_hand=Hand()
    
    #give the cards
    dealer_hand.add_card(the_deck.deal_card())
    dealer_hand.add_card(the_deck.deal_card())
    my_hand.add_card(the_deck.deal_card())
    my_hand.add_card(the_deck.deal_card())
    
    #check if was playing
    if in_play:
        score_dealer=score_dealer+1
    else:
        in_play=True

def hit():
    global score_dealer, in_play, outcome
    if in_play:
        #get a card
        my_hand.add_card(the_deck.deal_card())
        #check bust
        if my_hand.get_value()>21:
            outcome="You went bust and lose"
            score_dealer=score_dealer+1
            in_play=False
           
def stand():
    global outcome, score_dealer, score_player, in_play
    if in_play:
        #hit cards to dealer until value of 17 or higher
        while dealer_hand.get_value()<17:
            dealer_hand.add_card(the_deck.deal_card())
            
        #check situation
        if dealer_hand.get_value()>21:
            outcome="Dealer got busted. You win"
            score_player=score_player+1
        elif dealer_hand.get_value()>=my_hand.get_value():
            outcome="You lose"
            score_dealer=score_dealer+1
        else:
            outcome="You win"
            score_player=score_player+1
        
        in_play=False

# draw handler    
def draw(canvas):
    #title
    canvas.draw_text("Blackjack", [100, 70], 36, "Blue")
    
    #message of hit or deal
    next_step=""
    if in_play:
        next_step="Hit or stand?"
    else:
        next_step="New deal?"
        
    #title and cards of dealer
    canvas.draw_text("Dealer", [100, 130], 24, "Black")
    canvas.draw_text(outcome, [220, 130], 24, "Black")
    dealer_hand.draw(canvas, [100, 150])
    
    #title and cards of player
    canvas.draw_text("Player", [100, 370], 24, "Black")
    canvas.draw_text(next_step, [220, 370], 24, "Black")
    my_hand.draw(canvas, [100, 400])
    
    #score
    canvas.draw_text("Score ", [440, 30], 24, "Black")
    canvas.draw_text("Dealer: "+str(score_dealer), [430, 50], 24, "Black")
    canvas.draw_text("Player: "+str(score_player), [430, 70], 24, "Black")
    
    #if in play, hidde the card of dealer
    if in_play:
        pos=[100, 150]
        canvas.draw_image(card_back, CARD_BACK_CENTER, CARD_BACK_SIZE, [pos[0] + CARD_CENTER[0], pos[1] + CARD_CENTER[1]], CARD_SIZE)


# initialization frame
frame = simplegui.create_frame("Blackjack", 600, 600)
frame.set_canvas_background("Green")

#create buttons and canvas callback
frame.add_button("Deal", deal, 200)
frame.add_button("Hit",  hit, 200)
frame.add_button("Stand", stand, 200)
frame.set_draw_handler(draw)


# get things rolling
deal()
frame.start()

Día 115

2014-08-06T14:00:00.000+02:00

Una vez más, espoleado y parece que empieza a surtir efecto.

(enlace del autor original)

Todavía está en mente los anteriores y hoy han aparecido dos más, otros compañeros están programando para IOS cosillas, pequeñas y poca cosa, pero están haciendo cosas y con página web y esas cosas.

Revisando los requisitos, veo que piden conocimientos de C++ y ejemplos de trabajo y proyectos en los que puedan ver la calidad y poder usarlos como modo de selección.

Y me entra el miedo. Creo que ha sido esto último lo que me ha despertado, el temor a que me rechacen, tengo que conseguirlo como sea, tengo que hacer algo. Para ello necesito hacer muchas cosas que me permitan tener soltura para poder hacer unos pocos decentes con el que ganarme un puesto en el Máster.

Efectivamente es mi sueño, pero no puedo permitirme sufrir contratiempos para ponerme las pilas, podrían tener daños irreparables y no puedo permitírmelo.

¡Cojamos de nuevo la mochila!

Coursera

2014-02-22T15:12:00.002+01:00

Interesante plataforma que un profesor nos comentó en clase. Se trata de Coursera.

Sacado de la wikipedia:

Es una plataforma de educación virtual gratuita nacida en octubre de 2011 y desarrollada por académicos de la Universidad de Stanford con el fin de brindar oferta de educación masiva a la población mundial (Massive Online Open Course), con cursos en inglés y otros idiomas como el español, francés, italiano y chino. Coursera ofrece cursos gratis de temas variados a niveles universitarios pero abiertos a todos los sectores de la población.

No hay mucho más que añadir. Son gratuitos y te dan un certificado de haber hecho los cursos. Hay una variante en algunos cursos que puedes pagar por el curso (creo que no es mucho) y así poder obtener un certificado que es oficial y puede ser verificado. Pero el curso lo puedes tomar igualmente sin pagar.

Su estilo es poner una serie de videos como clases a la semana, los cuales puedes ver cuando quieras, y cada semana, te ponen un test sobre dicho contenido y/o un trabajo. Algunos hacen un test/examen al final del curso.

Lo que más me gusta es que subtitulan los vídeos, por lo que puedo tomar sin ningún problema las clases porque la mayoría las dan en inglés, pero también pueden ofrecer subtitulos en español.

De momento estoy a la espera de un par de certificados y a ver si soy capaz de terminar uno tercero. A ver como son.

No es que esté muy relacionado con mi viaje, pero es una gran fuente de conocimiento y hay muchas cosas sobre mi campo, incluyendo cosillas relacionadas sobre videojuegos, entre ellas, hice los cursos de introducción a python, que lo enseñaban haciendo minijuegos (casualmente los que llevo subiendo hace días jejeje), la enseñanza en videojuegos y C++ para C que lo dejé porque se pasó con la dificultad y no tenía tiempo.

También había probado un cursillo de teoría de juegos (que resultó ser economía), otro de interfaces que sigo sin saber qué era ese curso y tratando de terminar egiptología, que es algo que me inspira mucho y me gusta bastante.

Ya iré haciendo posts sobre los cursos que voy haciendo y mis impresiones sobre ellos, a ver que aprendo que me ayude para el camino.

Pong en python

2014-02-22T15:12:00.000+01:00

Creo que no necesita más descripción que el título. Las dos palas se controlan con s y w, y las flechas de dirección arriba y abajo. ¡A pasar el rato!

Una vez más, toca ejecutarlo en CodeSkulptor por la librería gráfica propia de la plataforma.

Pong: Pulsa para ver/ocultar el código

# Implementation of classic arcade game Pong

import simplegui
import random

# initialize globals - pos and vel encode vertical info for paddles
WIDTH = 600
HEIGHT = 400       
BALL_RADIUS = 20
PAD_WIDTH = 8
PAD_HEIGHT = 80
HALF_PAD_WIDTH = PAD_WIDTH / 2
HALF_PAD_HEIGHT = PAD_HEIGHT / 2
LEFT = False
RIGHT = True

#position[x,y] and velocity[x,y] of ball
ball_pos=[0,0]
ball_vel=[0,0]

#position[x,y] and velocity[x,y] of paddles
paddle_pos=[HEIGHT/2,HEIGHT/2]
paddle_vel=[0,0]

#score[left,rigth]
score=[0,0]

# initialize ball_pos and ball_vel for new bal in middle of table
# if direction is RIGHT, the ball's velocity is upper right, else upper left
def spawn_ball(direction):
    global ball_pos, ball_vel # these are vectors stored as lists
    ball_pos = [WIDTH/2, HEIGHT/2]
    ball_vel[0]=random.randrange(2, 4);
    ball_vel[1]=-1*random.randrange(1, 3);
    if direction==LEFT:
        ball_vel[0] =-1*ball_vel[0]


# define event handlers
def new_game():
    global score, paddle_pos
    score=[0,0]
    paddle_pos=[HEIGHT/2,HEIGHT/2]
    spawn_ball(LEFT)

#draw
def draw(c):
    # draw mid line and gutters
    c.draw_line([WIDTH / 2, 0],[WIDTH / 2, HEIGHT], 1, "White")
    c.draw_line([PAD_WIDTH, 0],[PAD_WIDTH, HEIGHT], 1, "White")
    c.draw_line([WIDTH - PAD_WIDTH, 0],[WIDTH - PAD_WIDTH, HEIGHT], 1, "White")     
    # update ball
    new_position_ball()
            
    # draw ball
    c.draw_circle(ball_pos,BALL_RADIUS,2,"White","White")
    
    # update paddle's vertical position, keep paddle on the screen
    modify_paddle(0)
    modify_paddle(1)
    
    # draw paddles
    c.draw_polygon(rectangle_paddle(0,paddle_pos[0]), 1, "White", "White")
    c.draw_polygon(rectangle_paddle(1,paddle_pos[1]), 1, "White", "White")
    
    #check the colision
    colision()
    
    # draw scores
    c.draw_text(str(score[0]),[WIDTH*(1/3.0),120],50, "Green")
    c.draw_text(str(score[1]),[WIDTH*(2/3.0),120],50, "Green")
     
#increase and decrease the velocity of paddles
def keydown(key):
    if key==simplegui.KEY_MAP["s"]:
        paddle_vel[0]+=5
    elif key==simplegui.KEY_MAP["w"]:
        paddle_vel[0]-=5
    elif key==simplegui.KEY_MAP["down"]:
        paddle_vel[1]+=5
    elif key==simplegui.KEY_MAP["up"]:
        paddle_vel[1]-=5
   
def keyup(key):
    if key==simplegui.KEY_MAP["s"]:
        paddle_vel[0]-=5
    elif key==simplegui.KEY_MAP["w"]:
        paddle_vel[0]+=5
    elif key==simplegui.KEY_MAP["down"]:
        paddle_vel[1]-=5
    elif key==simplegui.KEY_MAP["up"]:
        paddle_vel[1]+=5
        
#check if ball have colision with the paddle or the edge
def colision():
    #get the limits of paddle
    rigth_limit=WIDTH-PAD_WIDTH-BALL_RADIUS
    left_limit=PAD_WIDTH+BALL_RADIUS
    
    #check if ball colide with the edge
    if ball_pos[0]>=rigth_limit:
        #if yes, check the position of the paddle to increase velocity or score
        if colision_with_ball(paddle_pos[1])==1:
            ball_vel[0]+=ball_vel[0]*0.10
            ball_vel[1]+=ball_vel[1]*0.10
        else:
            score[0]+=1
            spawn_ball(LEFT)
        
    #check if ball colide with the edge
    elif ball_pos[0]<= left_limit:
        #if yes, check the position of the paddle to increase velocity or score
        if colision_with_ball(paddle_pos[0])==1:
            ball_vel[0]+=ball_vel[0]*0.10
            ball_vel[1]+=ball_vel[1]*0.10
        else:
            score[1]+=1
            spawn_ball(RIGHT)
            
#check if ball colides with the paddle
#return 1 if colides, 0 otherwise
def colision_with_ball(y):
    if ball_pos[1]<=y+HALF_PAD_HEIGHT and ball_pos[1]>=y-HALF_PAD_HEIGHT:
        return 1
    else:
        return 0

#move the paddle
def modify_paddle(paddle):
    upperPosition=paddle_pos[paddle]+paddle_vel[paddle]-HALF_PAD_HEIGHT
    downPosition=paddle_pos[paddle]+paddle_vel[paddle]+HALF_PAD_HEIGHT
    if not(upperPosition<0 or downPosition>HEIGHT):
            paddle_pos[paddle]+=paddle_vel[paddle]

#get the rectangle of paddle
def rectangle_paddle(position,y):
    point = [[0,0],[0,0],[0,0],[0,0]]
    side=0
    if position>0:
        side=WIDTH-PAD_WIDTH
        
    point[0] = [side, y-HALF_PAD_HEIGHT]
    point[1] = [side+PAD_WIDTH, y-HALF_PAD_HEIGHT]
    point[2] = [side+PAD_WIDTH, y+HALF_PAD_HEIGHT]
    point[3] = [side, y+HALF_PAD_HEIGHT]
    
    return point   

#update position ball
def new_position_ball():
    ball_pos[0] += ball_vel[0]
    ball_pos[1] += ball_vel[1]
    
    under_limit=HEIGHT-BALL_RADIUS
    upper_limit=BALL_RADIUS
    rigth_limit=WIDTH-PAD_WIDTH-BALL_RADIUS
    left_limit=PAD_WIDTH+BALL_RADIUS
    
    if ball_pos[0]>=rigth_limit:
        ball_vel[0]*=-1
        ball_pos[0]=rigth_limit
    elif ball_pos[0]<= left_limit:
        ball_vel[0]*=-1
        ball_pos[0]=left_limit
        
    if ball_pos[1]>=under_limit:
        ball_vel[1]*=-1
        ball_pos[1]=under_limit
    elif ball_pos[1]<=upper_limit:
        ball_pos[1]=upper_limit
        ball_vel[1]*=-1
            


# create frame
frame = simplegui.create_frame("Pong", WIDTH, HEIGHT)
frame.set_draw_handler(draw)
frame.set_keydown_handler(keydown)
frame.set_keyup_handler(keyup)
frame.add_button("Reset", new_game)


# start frame
new_game()
frame.start()

Día 114

2014-02-22T15:11:00.000+01:00

El juego que me inspiró, Faraón. Un gran juego que marcó mi vida y es la bandera de mi sueño. Su música no me deja indiferente y no soy capaz de expresar lo que esa música despierta en mí.

Hoy no hubo nada nuevo, pero he sido de nuevo espoleado para reaccionar de una vez. ¿Cuánto ya de la última vez que actualicé? Mucho, como si mi sueño no fuera tal y no me interesara.

Trabajo fin de grado son las palabras claves. El final de la carrera no anda tan lejos y eso implica que ya antes de terminar, tengo que vigilar el máster de videojuegos. Un máster que se supone que hará mi sueño realidad.

Pero antes de eso, tendré que hacer el trabajo fin de grado, y la verdad es que no tengo la más mínima idea de que hacerlo. Tan sólo que tiene que ser un trabajo decente, un trabajo o proyecto que destaque y, a ser posible, relacionado con lo que quiero hacer.

Hoy me enteré de un fichero en las que se ofertaban unos TFG y les eché un vistazo. La verdad es que no hay muchos que me llamen la atención, y de videojuegos sólo encontré dos, uno de ellos, el más interesante, es un trabajo sobre OpenGL. Y lo mejor, lo lleva una profesora que me parece buena y con la que tengo cierta confianza. La verdad es que me haría ilusión tenerla de tutora para el TFG y encima de algo que se relaciona con lo mío.

Todavía tengo que pensar muy bien que haré, y me tomaré mi tiempo para decidir. Pero me han dado unas locas ganas de mirarme OpenGL e ir haciendo algo. Lo que sea para tener algo hecho y poder de verdad hacer algo bueno.

El cronómetro en python

2013-12-06T21:14:00.001+01:00

Siguiendo con los minijuegos en python, traigo el cronómetro, el cual consiste en tratar de parar el reloj en el segundo exacto (2.0 y no 2.1).

Os recuerdo que usa una librería concreta del curso donde los hago, por lo que necesitáis copiar el código en CodeSkulptor para hacerlo funcionar.

Cronómetro: Pulsa para ver/ocultar el código

# template for "Stopwatch: The Game"
#import the graphics
import simplegui

# define global variables
#time
miliseconds = 0
#success/attempts
success=0
attempts=0

# format time into formatted string A:BC.D
def format(t):
    #take the parts of the time
    miliseconds = t % 10
    seconds = (t/10) % 60 # 60 seconds is a minute
    minutes = (t/600) % 10
    #first the minutes
    time=str(minutes)+ ":"
    #check if neccessary to put another digit(zero)
    if seconds<10:
        time=time+ "0"
    # concat the rest of the formatted string
    time=time + str(seconds) + "." + str(miliseconds)
    return time
    
    
# define event handlers for buttons; "Start", "Stop", "Reset"
# Start
def start():
    stopwatch.start()
    
#Stop
def stop():
    #check if is was running before make modifications
    if stopwatch.is_running():
        global attempts, success
        stopwatch.stop()
        #the method returns 1 if succes, 0 otherwise
        success=success + stop_at_second(miliseconds)
        attempts+=1
 
# Reset
def reset():
    global miliseconds, attempts
    stopwatch.stop()
    miliseconds=0
    attempts=0
    
# define succcess, return 1 if success, 0 otherwise
def stop_at_second(miliseconds):
    second = miliseconds % 10
    if second==0:
        return 1
    else:
        return 0

# define event handler for timer with 0.1 sec interval
def tick():
    global miliseconds
    #only count miliseconds if clock is running
    if stopwatch.is_running():
        miliseconds=miliseconds+1

# define draw handler
def draw(canvas):
    #get clock
    clock=format(miliseconds)
    #show clock and success
    canvas.draw_text(clock, [95,200], 54, "White")
    canvas.draw_text(str(success)+"/"+str(attempts), [230,30], 26, "Green")
    
# create frame
frame=simplegui.create_frame("Stopwatch", 300, 300)

# register event handlers
stopwatch=simplegui.create_timer(100, tick)

frame.add_button("Start", start, 200)
frame.add_button("Stop", stop, 200)
frame.add_button("Reset", reset, 200)
frame.set_draw_handler(draw)

# start frame
frame.start()

Adivina el número en python

2013-12-06T21:14:00.000+01:00

Código en python del sencillo juego de adivinar el número. Como siempre, lo hice pilladísimo de tiempo, asi que el código sigue siendo mierdecilla pinchada en un palo. Pero al menos hay código existente.

En este proyecto ya hay un pequeño problema, y es que este código está hecho con el cursillo de coursera, el cual usan una plataforma propia donde podemos escribir y ejecutar python. Al ser de introducción y demás, resolvieron la parte gráfica ofreciendo una librería desarrollada por ellos en la plataforma para que no tengamos que preocuparnos de ello.

Resultado, este código no es portable y si queréis ver el código en funcionamiento, tenéis que ir a CodeSkulptor y pegar el código. De CodeSkulptor sale la librería gráfica que aparece en el código.

Tampoco os emocionéis con esto de los gráficos, que no dibujamos nada aquí. :P

Guess a number: Pulsa para ver/ocultar el código

#import the library for gui, random numbers and maths
import simplegui
import random
import math

#Global variables
# secret number
secret_number = 0
# attempts remaining
attempts = 0
# maximum of the range
maximum_range=100


# start new game
def new_game():
    global secret_number
    global attempts

    print
    #set a secret number
    secret_number = random.randrange(0,maximum_range)
    #set attempts according the range
    #with logarithm base 2 of the maximum (and ceiling)
    #I get the best number of attempts
    attempts = int(math.ceil(math.log(maximum_range,2)))
    
    #show the range of the game and the attempts
    print "Range is [0," + str(maximum_range)+")"
    print "Number of attempts: " + str(attempts)
    print

# define event handlers for control panel
def range100():
    # button that changes range to range [0,100) and restarts
    global maximum_range
    maximum_range=100
    new_game()

def range1000():
    # button that changes range to range [0,1000) and restarts
    global maximum_range
    maximum_range=1000
    new_game()
    
#Guess of the user, main of the game
def input_guess(guess):
    #show what I write
    print "Guess was " + guess
    
    #Error if is not a number(digit)
    if not guess.isdigit():
        print "Write a number!"
        
    else:
        #convert the string to int for comparison
        number = int(guess)
        #control the range
        if number>=0 and numbersecret_number:
            print "Lower"
        else:
            print "Higher"
    
# create frame
frame = simplegui.create_frame("Guess a number!", 200, 200)

# register event handlers for control elements
frame.add_button("Range is [0,100)", range100, 200) 
frame.add_button("Range is [0,1000)", range1000, 200)
#I store the input, so later I can clear the text inside the input
input_text=frame.add_input("Enter a guess", input_guess, 200)

# call new_game and start frame
new_game()

Make I

2013-12-06T21:13:00.000+01:00

Algo muy útil para los proyectos y que los IDE (programas que ayudan a programar) hacen de forma automática, son los makefiles. Make es una orden que se aplica a cualquier tarea donde algunos ficheros deben ser actualizados a partir de otros cuando éstos cambian.

Se basa un un fichero makefile donde se describen las relaciones entre los ficheros que componen el programa y las órdenes necesarias para cada uno de ellos. De forma automática actualiza sólo lo necesario, lo que haya cambiado y no todo.

#make de un programa
programa: objetivo2, objetivo3
comando orden
comando orden

objetivo2: objetivo3
comando orden
comando orden

objetivo3:
comando orden
comando orden demasiado largo pero que muy largo \
y el comando sigue en la segunda línea

Cada fichero del programa es un objetivo (target) de una regla, menos cabeceras y fuentes.
Cada objetivo aparece al principio de una línea seguido de dos puntos (:) y a continuación las dependencias (lo que necesita previamente).
Tras cada objetivo e indentados con tabulaciones, van las ordenes.
Make comienza con la primera regla que encuentra, por lo que se suele empezar con el programa en sí, ya que de él depende todo lo demás.
Si una línea es muy larga, se puede dividir en dos con \
Para poner comentarios se colocan después de #

A veces hay objetivos/dependencias que se repiten, por lo que podemos guardarlos en una variable

variable= dependencia1.o cabecera1.h objetivo1: $(variable)
orden ${variable}

Para usar la variable se puede usar tanto los paréntesis como las llaves.
Podemos usarlo en las dependencias o en las órdenes de la regla.

A veces sólo especificamos las dependencias (no hay órdenes) y vemos que para varios objetos, las dependencias se repiten. Se pueden agrupar de otra forma, pasando de varias líneas a unas pocas. Por ejemplo:

objetivo1: cabecera1.h cabecera2.h
objetivo2: cabecera1.h cabecera2.h
objetivo3: cabecera1.h cabecera2.h
objetivo4: cabecera1.h cabecera2.h

objetivo1 objetivo2 objetivo3 objetivo4: cabecera1.h cabecera2.h

Esta es la estructura básica y general de un makefile. El próximo día empezamos a hablar de las órdenes y de más cosas que tiene.

Día 109

2013-12-06T21:12:00.000+01:00

Un día malo y de cabreo para mí... tanto tiempo estudiando y tanto tiempo desperdiciado porque no hay manera de concentrarse. Junta esto con Tweetalk y mi prácticamente abandono del blog, y ¡toma coctelera!

Voy a seguir otra estrategia, ya que veo que apenas actualizo, pero si voy haciendo algunos avances, voy al menos dejarme apuntes para que cuando actualice, ponga todo, de ahí que los días transcurridos, no coincidirán con el conteo del calendario, pero sí con la realidad.

Y hoy toca hablar de tweetalk, un servicio que te permite chatear con tus seguidores de Twitter. En el enlace tenéis una mejor explicación y la verdad es que merece la pena. Lo han hecho un par de compañeros míos de la universidad y hay que reconocerles un trabajo bastante bien hecho, con certificado de seguridad y todo.

¿Conocéis ese sentimiento llamado envidia? Habéis acertado, tengo envidia, pero de la buena. Hay gente que piensa que no existe la envidia buena, que esa no es envidia, sino admiración. Sea lo que sea, me alegro por ellos, se lo han currado. Mi envidia viene de que me gustaría poder alcanzar yo también algo así, un servicio, una aplicación, un juego... lo que sea. Esa forma de trabajar y destacar con algo que pueda llegar muy lejos.

Cosas así, después de tanta gente diciendo que yo lo valgo, que yo puedo hacer algo así, que cómo es que no se me ha ocurrido a mí y no lo he hecho, hace que me sienta inútil. Y si veo el trabajo que he reflejado en el blog, sigo pensando en que soy inútil y además en que quizás no es tanto mi sueño como pensaba. Pero incluso así, sigo pensando que es mi sueño y ahí quiero llegar, ¿quizás estoy demasiado seguro de que llegaré pase lo que pase?

Dependo demasiado de las palabras de ánimo de los demás. El mío no me hace efecto.

rock Spock paper lizard scissors en phyton básico

2013-10-25T23:28:00.001+02:00

En una ocasión os mencioné coursera, y coursera consigue que haga este código muy básico de python. ¿Conocéis el juego de The Big Bang Theory? Os dejo un video muy ilustrativo:

Una imagen para tener delante las relaciones del juego, y aquí el código acorde a la última versión de python ^^

juego.py: Pulsa para ver/ocultar el código

# Rock-paper-scissors-lizard-Spock template

# The key idea of this program is to equate the strings
# "rock", "paper", "scissors", "lizard", "Spock" to numbers
# as follows:
#
# 0 - rock
# 1 - Spock
# 2 - paper
# 3 - lizard
# 4 - scissors


#import the library for random numbers
import random

# Convert the number to the correspond number
def number_to_name(number):
    #mod five to avoid wrong numbers
    number=number%5
    if number==0 :
        result="rock"
    elif number==1:
        result="Spock"
    elif number==2:
        result="paper"
    elif number==3:
        result="lizard"
    else:
        result="scissors"
    
    return result;

#convert the name to number
def name_to_number(name):
    result=None
    if name=="rock":
        result=0
    elif name=="Spock":
        result=1
    elif name=="paper":
        result=2
    elif name=="lizard":
        result=3
    elif name=="scissors":
        result=4
    else:
        print("Wrong name!! The options are: ")
        print("rock,Spock,paper,lizard,scissors")
        print("")
        result=-1 # return a negative number for error
    
    return result;

#game
def rpsls(name): 
    # convert name to player_number using name_to_number
    player_number=name_to_number(name)
    
    #check first if I have no errors
    if player_number >=0 :
        # compute random 
        computer_number=random.randrange(0,5)

        # compute difference of player_number and comp_number modulo five
        result_game=(player_number-computer_number)%5
        # use if/elif/else to determine winner
        if result_game==0:
            who_wins="Player and computer tie!"
        elif result_game > 2:
            who_wins ="Computer wins!"
        else :
            who_wins="Player wins!"
        
        # convert comp_number to name using number_to_name
        name_computer=number_to_name(computer_number)
        # print results
        print("Player chooses " + name)
        print("Computer chooses "+name_computer)
        print (who_wins)
        print
    
# test your code
rpsls("rock")
rpsls("Spock")
rpsls("paper")
rpsls("lizard")
rpsls("scissors")
#test any error
rpsls("wrong name")

Código Joysticks con SDL

2013-10-25T23:28:00.000+02:00

Os traigo dos ejemplos de código con joysticks. ¡Me lo he pasado como un niño pequeño!

El primer código simplemente lista los joystick conectados y algunos detalles, mientras que el segundo mueve un personaje (imagen) por la pantalla. Es una chorrada, ¡pero cómo me lo he pasado! Diez minutos moviendo el joystick como un imbécil viendo cómo se movía el personaje al mismo tiempo.

Información joysticks: Pulsa para ver/ocultar el código

// Programa de pruebas. Información acerca del joystick
// Abriendo un dispositivo


#include <iostream>
#include <SDL/SDL.h>

using namespace std;
int main(){
 // Iniciamos el subsistema de video
 if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) < 0) {
  cerr << "No se pudo iniciar SDL: %s\n" << SDL_GetError();
  exit(1);
 }
 atexit(SDL_Quit);
 
 // Comprobamos que sea compatible el modo de video
 if (SDL_VideoModeOK(640, 480, 24, SDL_HWSURFACE|SDL_DOUBLEBUF) == 0) {
  cerr << "Modo no soportado: " << SDL_GetError() << endl;
  exit(1);
 }
 
 // Consultamos el número de joysticks existentes
 int num_joysticks = SDL_NumJoysticks();
 
 // Si no hay joysticks conectados
 if (num_joysticks < 1) {
  cerr << "Conecte un dispositivo de juego antes de ejecutar" << endl;
  exit(1);
 } else {
  // Al menos hay uno
  cout << "Hay conectados " << num_joysticks << " joysticks. " << endl;
 }
 
 // Mostramos información de cada uno de los joysticks
 for ( int i = 0; i < num_joysticks; i++) {
  // Obtenemos el nombre del joystick
  const char *nombre = SDL_JoystickName(i);
  // Lo abrimos
  SDL_Joystick *joy = SDL_JoystickOpen(i);
  // Mostramos en pantalla toda la información
  // disponible del joystick
  cout << "Abrimos el joystick " << nombre << " - " << i << endl;
  cout << "\tTiene " << SDL_JoystickNumAxes(joy) << " ejes" << endl;
  cout << "\tTiene " << SDL_JoystickNumButtons(joy) << " botones" << endl;
  // Cerramos el joystick
  SDL_JoystickClose(joy);
 }
 return 0;
}

Manejo Joysticks: Pulsa para ver/ocultar el código

// Programa de pruebas. Joystick captura de movimientos
// Consultando el estado del joystick directamente

#include <iostream>
#include <SDL/SDL.h>
using namespace std;

int main() {

 // Iniciamos el subsistema de video
 if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_JOYSTICK) < 0) {
  cerr << "No se pudo iniciar SDL: " << SDL_GetError() << endl;
  exit(1);
 }


 atexit(SDL_Quit);

 // Comprobamos que sea compatible el modo de video
 if (SDL_VideoModeOK(640, 480, 24, SDL_HWSURFACE|SDL_DOUBLEBUF) == 0) {
  cerr << "Modo no soportado: " << SDL_GetError() << endl;
  exit(1);
 }


 // Establecemos el modo de video
 SDL_Surface *pantalla;
 pantalla = SDL_SetVideoMode(640, 480, 24, SDL_HWSURFACE|SDL_DOUBLEBUF);

 if (pantalla == NULL) {
  cerr << "No se pudo establecer el modo de video: " << SDL_GetError() << endl;
  exit(1);
 }
 
 // Cargamos una imagen en una superficie
 SDL_Surface *personaje = SDL_LoadBMP("Imagenes/personaje.bmp");
 if (personaje == NULL) {
  cerr << "No se pudo cargar la imagen: " << SDL_GetError() << endl;
  exit(1);
 }
 
 // Establecemos el color de la transparencia
 // No será mostrado al realizar el blitting
 SDL_SetColorKey(personaje, SDL_SRCCOLORKEY|SDL_RLEACCEL, SDL_MapRGB(personaje->format, 255, 255, 255));
 // Posición inicial del personaje
 SDL_Rect posicion;
 posicion.x=300;
 posicion.y=200;
 posicion.w=personaje->w;
 posicion.h=personaje->h;
 
 // Copiamos la imagen en la superficie principal
 SDL_BlitSurface(personaje, NULL, pantalla, &posicion);
 // Mostramos la pantalla "oculta" del búffer
 SDL_Flip(pantalla);
 // Si hay un joystick conectado lo abrimos
 SDL_Joystick *joy;
 if (SDL_NumJoysticks() > 0) {
  joy = SDL_JoystickOpen(0);
  cout << "\nAbrimos el joystick " << SDL_JoystickName(0) << " para la prueba. " << endl;
 } else {
  cout << "Para llevar acabo esta prueba debe haber un joystick " << "conectado. Si es así compruebe su configuración" << endl;
  exit(1);
 }
 
 // Mostramos información del dispositivo
 int num_ejes = SDL_JoystickNumAxes(joy);
 int num_botones = SDL_JoystickNumButtons(joy);
 cout << "Este joystick tiene " << num_ejes << " ejes y " << num_botones << " botones." << endl;
 cout << "\nPulse ESC para salir.\n" << endl;
 // Variable auxiliar
 SDL_Event evento;
 for ( ; ; ) {
  // Actualizamos el estado del joystick
  SDL_JoystickUpdate();
  // Recorremos todos los ejes en búsqueda de cambios de estado
  for ( int i = 0; i < num_ejes; i++) {
   int valor_eje = SDL_JoystickGetAxis(joy, i);
   //cout << "Eje " << i << " -> " << valor_eje << endl;
   if (valor_eje != 0) {
    if (i == 0) {
     if (valor_eje > 0)
      posicion.x++;
     if (valor_eje < 0)
      posicion.x--;
    } else {
     if (valor_eje > 0)
      posicion.y++;
     if (valor_eje < 0)
      posicion.y--;
    }
   }
  }
  
  // Limpiamos la pantalla
  SDL_FillRect(pantalla, NULL, 0);
  // Cambiamos la posición del personaje
  SDL_BlitSurface(personaje, NULL, pantalla, &posicion);
  // Actualizamos la pantalla principal
  SDL_Flip(pantalla);
  // Recorremos todos los botones en búsqueda acciones
  for ( int i = 0; i < num_botones; i++) {
   int pulsado = SDL_JoystickGetButton(joy, i);
   if (pulsado) {
    cout << "Ha pulsado el botón " << i << endl;
   }
  }
  // Bucle que controla eventos de salida
  while (SDL_PollEvent(&evento)) {
   if (evento.type == SDL_KEYDOWN) {
    if (evento.key.keysym.sym == SDLK_ESCAPE) {
     SDL_JoystickClose(joy);
     return 0;
    }
   }
 
   if (evento.type == SDL_QUIT) {
    SDL_JoystickClose(joy);
    return 0;
   }
  }
 }
}

Desarrollo de videojuegos en SDL VII - Joystick

2013-10-25T23:27:00.003+02:00

Joystick
SDL le dedica un subsistema sólo para ello, pero no es le más completo debido a que hay muchos y no siguen un estándar.

Gestión mediante eventos
Los ejes de movimiento del joystick producen el evento de tipo SDL_JoyAxisEvent:

typedef struct{
Uint8 type; // al mover el eje produce SDL_JOYAXISMOTION
Uint8 which; //que joystick
Uint8 axis; //que eje
Sint16 value; //valor del movimiento
} SDL_JoyAxisEvent;

El valor del movimiento depende de si es un eje gradual o analógico (-32768,32768) o un eje digital o determinista (mínimo, cero, máximo).

En el caso de los botones producen:

typedef struct{
Uint8 type; // SDL_JOYBUTTONDOWN, SDL_JOYBUTTONUP
Uint8 which; //que joystick
Uint8 button; //que botón
Uint8 state; //redundante: SDL_PRESSED, SDL_RELEASED
} SDL_JoyButtonEvent;

Inicialización del joystick
Tenemos que inicial el subsistema del joystick al inicio con SDL_Init, pasańdole la constante SDL_INIT_JOYSTICK, para posteriormente abrir el joystick. Tener en cuenta que los index empiezan en cero.

SDL_Joystick* SDL_JoystickOpen(int index);

Cerrar el joystick

void SDL_JoystickClose(SDL_Joystick *joystick);

Que joysticks están abiertos:

int SDL_JoystickOpened(int index);

Eventos menos usados en Joysticks corresponden a los minijoystick o hat, el cual tiene 9 posiciones.

typedef struct{
Uint8 type;
Uint8 which;
Uint8 hat;
Uint8 value;
}SDL_JoyHatEvent

Las nueve posiciones de las que dispone se determinan con 5 constantes:

SDL_HAT_CENTERED
SDL_HAT_UP
SDL_HAT_RIGHT
SDL_HAT_LEFT
SDL_HAT_DOWN

Si no queremos hacer combinaciones con OR, tenemos las siguientes constantes:

SDL_HAT_RIGHTUP
SDL_HAT_RIGHTDOWN
SDL_HAT_LEFTUP
SDL_HAT_LEFTDOWN

Otro elemento menos usado todavía es el trackball, su evento sólo es válido cuando no está integrado en un ratón o teclado.

typedef struct{
Uint8 type;
Uint8 which;
Uint8 ball; //SDL presupone que puede haber varios en un joystick
Sint16 xrel, yrel;
}SDL_JoyBallEvent;

Acceso directo al Joystick
Además de consultar el estado del joystick, podemos saber sus características (botones y ejes).

Número de joysticks

int SDL_NumJoysticks(void);

Nombre del Joystick

const char *SDL_JoystickName(int index);

Número de ejes

int SDL_JoysticksNumAxes(SDL_Joystick *joystick);

Número de botones

int SDL_JoysticksNumButtons(SDL_Joystick *joystick);

Desarrollo de videojuegos en SDL VI - Ratón

2013-10-25T23:27:00.001+02:00

Llegados hasta aquí, me gustaría recordar que nada de esto es mi autoría y viene del Tutorial de libSDL para la programación de videojuegos. Tampoco está escrito a modo de divulgación, sino a modo de constancia de lo aprendido en mi viaje y, por tanto, hasta para mi opinión, es un poco desastre las entradas escritas hasta ahora.

Ratón
Tiene dos tipos de eventos
De movimiento: contiene la posición del puntero, posición relativa respecto al anterior movimiento y si hay botón pulsado y cuál.
De pulsación: muy similar al de teclado.

typedef struct{
Uint8 type; // SDL_MOUSEMOTION
Uint8 state;
Uint16 x,y;
Uint16 xrel, yrel; //posición relativa
} SDL_MouseMotionEvent

state: este campo contiene los flags de los botones. Puede ser consultado con SDL_BUTTON() pasándole 1, 2 ó 3 para preguntar por dicho botón. (1= botón izquierdo, 2=botón central, 3=botón derecho).

También tenemos las constantes SDL_BUTTON_LMASK,SDL_BUTTON_MMASK Y SDL_BUTTON_RMASK.

typedef struct{
Uint8 type; //SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP
Uint8 button; // SDL_BUTTON_LEFT, SDL_BUTTON_RIGHT, SDL_BUTTON_MIDDLE
Uint8 state; //información redundante SDL_PRESSED, SDL_RELEASED
Uint16 x,y;
} SDL_MouseButtonEvent;

Para consultar el estado del ratón tenemos:

Uint8 SDL_GetMouseState(int *x, int *y);
Uint8 SDL_GetRelativeMouseState(int *x, int *y);

Podemos cambiar la apariencia del cursor teniendo en cuenta la estructura del cursor

struct{
SDL_Rect area; //rectángulo que define el área del cursor
Sint16 hot_x, hot_y; //punto de acción del cursor
Uint8 *data; //datos de pixel del cursor en blanco y negro
Uint8 *mask; //máscara del cursor en blanco y negro
Uint8 *save[2]; //lugar donde se almacenará el cursor
WMCursor *wm_cursor; //puntero al cursor del gestor de ventanas
}SDL_Cursor

Crear el cursor:

SDL_Cursor *SDL_CreateCursor(Uint8 *data, Uint8 *mask, int w, int h, int hot_x, int hot_y);

El ancho debe ser múltiplo de ocho.
Data y mask son dos imágenes monocromáticas que se combinan. Los tamaños cumplen: vectorSize= h * w/8. Ejemplo: para almacenar un cursor de 32x32 se necesita 32 x 4 bytes.
Las combinaciones dan:
Data+Mask=resultado 0+0=transparente
0+1=blanco
1+0=color invertido si se puede, si no, negro
1+1=negro

Para setear el cursor:

void SDL_SetCursor(SDL_Cursor *cursor);

Si queremos guardar el anterior cursor:

SDL_Cursor *SDL_GetCursor(void);

Para liberarlo:

void SDL_FreeCursor(SDL_Cursor *cursor);

Si queremos colocar el cursor en un determinado sitio tenemos:

void SDL_WarpMouse(Uint16 x, Uint16 y);

Para mostrar/ocultar el cursor:

int SDL_ShowCursor(int toggle);

El cual devuelve el estado anterior. Los valores son:

cero: oculto
uno:visible

Día 82

2013-10-25T23:27:00.000+02:00

Hoy ya he podido organizar mejor mi tiempo y vengo con bastantes cosas que había hecho en días anteriores y no había escrito. Y todavía me quedan varias cosas por escribir, que dejaré para el próximo día.

Hoy ha sido un buen día, no lo he dedicado mucho a recorrer mi camino, pero si ha sido aprovechado para otras cosas de las que os hablaré en otra entrada.

Pero de lo que sí hablaré, es que del tutorial que llevo tanto tiempo con él y que es prácticamente todo lo que escribo aquí, he llegado a la parte de los eventos con los joystick, y casualidad de la vida, mi compañero de piso tiene un joystick que tomé prestado para probar.

Tendría que haberme grabado para ver la ilusión con la que manejaba el joystick para simplemente mover una imagen por la pantalla. Me recordó a los niños que con poca cosa se ilusionaban, véase, unas canicas, una peonza, una pistolita de juguete... ¡ya ni te cuento si tenían una consola con un juego!

Lo que me lleva a recordar mi primera consola. Creo que no llegué a contaros cómo cogí la mochila e inicié este viaje tan... tan... perdido e ingenuo. Los mundos del videojuego son mucho más grandes de lo que pensaba aunque a veces al mismo tiempo parezca tan pequeño.

Algún día os contaré la historia si no la conté ya. Volviendo al día (o mejor dicho, a todos los días anteriores que no conté), he retomado un poco la playstation 2 y jugando a uno de los juegos que más me inspiran, Metal Gear Solid (ahora estoy jugando al 2). Eso si, poco a poco, que tengo que racionar mi tiempo.

Y en parte ha pasado porque otra vez, mi querido Deimos ha caido más enfermo que antes, y esta vez no tengo seguro médico que me cubra. Me toca pelear más que antes por conseguir darle de nuevo vida aunque mucho me temo que esta vez la solución tendrá que ser radical.

Al menos Lyria sigue conmigo. Pero estoy viendo que le estoy dando mucha carga, además de la que le corresponde llevar, está llevando mucho del peso de Deimos y no tiene tanta potencia. Ya hasta la universidad se empieza a resentir con la ausencia de Deimos.

Pero bueno, espero poder resolver pronto el problema, mientras tanto, ¡ahora a la dulce camita! Que ya hay sueño y mucho que hacer mañana.

Sinergia sin control

2013-10-24T23:55:00.001+02:00

Amenizando un poco mi vida, leo cómics, tanto en papel como en web, y uno de los que suelo leer es Sinergia sin control, con el que suelo identificarme (y como yo, seguro muchos informáticos) y otras en las que no me identifico pero seguro no tardará en tocarme...

Eso si, humor a raudales!! Aquí una prueba que no es de las más divertidas ni de las mejores que tiene, pero que me parece buenísima.

Códigos SDL - eventos básicos teclado y ratón

2013-10-24T23:55:00.000+02:00

Unos pocos códigos para estudiar y ver su funcionamiento, ~~copiados~~ basados en el tutorial con el que llevamos estos días.

En este caso son eventos de teclado y ratón. Incluyendo un cambio de cursor del ratón, el cual salió muy raro y no sé si es que está mal el código que había en el tutorial o mi ordenador lo ve raro.

Este código incluye capturar eventos de teclado, usando las flechas para mover el personaje por la pantalla y activando la repetición de teclas.

Repetición de teclas: Pulsa para ver/ocultar el código

#include <SDL/SDL.h>
#include <iostream>

using namespace std;

int main(){
 //genero pantallas
 SDL_Surface *pantalla, *imagen;
 //guardo evento
 SDL_Event evento;
 
 //variable recuadro para la imagen a cargar
 SDL_Rect posicion;
 
 //iniciar SDL
 if(SDL_Init(SDL_INIT_VIDEO)<0){
  cerr << "No se pudo inicializar SDL: " << SDL_GetError() << endl;
  exit(1);
 }
 
 //cierre..
 atexit(SDL_Quit);
 
 //comprobar disponibilidad video
 if(SDL_VideoModeOK(640,480,24, SDL_HWSURFACE|SDL_DOUBLEBUF)==0){
  cerr << "Modo de video no soportado: " << SDL_GetError() << endl;
  exit(1);
 }
 
 //iniciamos video
 pantalla=SDL_SetVideoMode(640,480,24,SDL_HWSURFACE|SDL_DOUBLEBUF);
 
 //comprobamos errores
 if(pantalla==NULL){
  cerr << "Error de pantalla: " << SDL_GetError() << endl;
  exit(1);
 }
 
 //cargamos la imagen
 imagen=SDL_LoadBMP("barco.bmp");
 if(imagen==NULL){
  cerr << "Error cargando imagen: " << SDL_GetError() << endl;
  exit(1);
 }
 
 //establezco donde copiarlo
 posicion.x=100;
 posicion.y=0;
 posicion.h=imagen->h;
 posicion.w=imagen->w;
 
 //copiamos la imagen
 SDL_BlitSurface(imagen, NULL, pantalla, &posicion);
 //mostramos
 SDL_Flip(pantalla);
 //liberamos la imagen
 //SDL_FreeSurface(imagen);


 int repeat = SDL_EnableKeyRepeat(1, SDL_DEFAULT_REPEAT_INTERVAL);
 if (repeat < 0) {
 cerr << "No se pudo establecer el modo repetición: "<< SDL_GetError() << endl;
 }else{
  cout << "activado repeticón de tecla" << endl;
 }
 
 //movemos la imagen
 while ( true ) { // o bien for( ; ; )
  while (SDL_PollEvent(&evento)) { 
   if (evento.type == SDL_KEYDOWN) {
    switch (evento.key.keysym.sym) {
     case SDLK_UP:
      posicion.y -= 4;
      if (posicion.y < 0)
       posicion.y = 0;
      break ;
     
     case SDLK_DOWN:
      posicion.y += 4;
      if (posicion.y > 480 - posicion.h)
       posicion.y = 480 - posicion.h;
      break ;
    
     case SDLK_RIGHT:
      posicion.x += 4;
      if (posicion.x > 640 - posicion.w)
       posicion.x = 640 -posicion.w;
      break ;
     case SDLK_LEFT:
      posicion.x -= 4;
      if (posicion.x < 0)
       posicion.x = 0;
      break ;
     case SDLK_ESCAPE:
      SDL_FreeSurface(imagen);
      return 0;
     case SDLK_f:     
      SDL_WM_ToggleFullScreen(pantalla);
      break ;
     default :
      cout << "Ha pulsado otra tecla" << endl;
    }
   } 
   // Limpiamos la pantalla
   SDL_FillRect(pantalla, NULL, 0);
   // Cambiamos la posición del personaje
   SDL_BlitSurface(imagen, NULL, pantalla, &posicion);
   // Actualizamos la pantalla principal
   SDL_Flip(pantalla);
   if (evento.type == SDL_QUIT) {
    SDL_FreeSurface(imagen);
    return 0;
   }
  }
 }
}

Estos tres códigos van juntos y es el código referente al ratón, en el que se pueden ver por consola las coordenadas del ratón, con click izquierdo se cambia de cursor, click derecho oculta/muestra el cursor y el botón central resetea dejando el cursor por defecto y en el centro.

cursor.h: Pulsa para ver/ocultar el código

// Listado: cursor.h
//
// Funciones para personalizar el cursor mediante una imagen XPM
//

#ifndef _CURSOR_H_
#define _CURSOR_H_

#include <SDL/SDL.h>

// Tamaño del apuntador o cursor

const int TAMANO = 32;
// Pasamos una matriz con una imagen XPM y nos devuelve
// un cursor que utilizar con SDL
SDL_Cursor *Cursor_personalizado_XPM( const char *matriz[]);

#endif

cursor.cpp: Pulsa para ver/ocultar el código

// Listado: cursor.cpp
//
// Implementación

#include <iostream>
#include "cursor.h"

SDL_Cursor *Cursor_personalizado_XPM( const char *matriz[]){
 // Variables auxiliares
 int i, fila, col;
 Uint8 data[4 * TAMANO]; // (h * w / 8)
 Uint8 mask[4 * TAMANO];
 //int hot_x, hot_y;
 i = -1;
 // Recorremos toda la matriz
 for ( fila = 0; fila < TAMANO; ++fila ) {
  for ( col = 0; col < TAMANO; ++col ) {
   // Si no es múltiplo de 8, desplazamos
   if ( col % 8 ) {
    data[i] <<= 1;
    mask[i] <<= 1;
   } else {
    ++i;
    data[i] = mask[i] = 0;
   }

   switch (matriz[4 + fila][col]) {
    case 'X':
     data[i] |= 0x01;
     mask[i] |= 0x01;
     break;

    case '.':
     mask[i] |= 0x01;
     break ;

    case ' ':
     break;
   }
  }
 }
 return SDL_CreateCursor(data, mask, TAMANO, TAMANO, 15, 15);
}

main.cpp: Pulsa para ver/ocultar el código

// Listado 6 - Eventos
//
// Listado: main.cpp
// Programa de pruebas. Eventos de ratón. Personalización del cursor
// Este programa prueba diferentes funciones
// referentes al manejo del ratón

#include <iostream>
#include <iomanip>

#include <SDL/SDL.h>
#include "cursor.h"

using namespace std;

int main(){
 // Iniciamos el subsistema de video
 if (SDL_Init(SDL_INIT_VIDEO) < 0) {
  cerr << "No se pudo iniciar SDL: " << SDL_GetError() << endl;
  exit(1);
 }

 atexit(SDL_Quit);

 // Comprobamos que sea compatible el modo de video
 if (SDL_VideoModeOK(640, 480, 24, SDL_HWSURFACE|SDL_DOUBLEBUF) == 0) {
  cerr << "Modo no soportado: " << SDL_GetError() << endl;
  exit(1);
 }

 // Establecemos el modo de video
 SDL_Surface *pantalla;
 pantalla = SDL_SetVideoMode(640, 480, 24, SDL_HWSURFACE|SDL_DOUBLEBUF);

 if (pantalla == NULL) {
  cerr << "No se pudo establecer el modo de video: " << SDL_GetError() << endl;
  exit(1);
 }
 
 // Imagen en XPM para personalizar el cursor
 const char *punto_mira[] = {
  // ancho alto num_colors bytes_per_pixel */
  " 32 32 3 1",
  // definición de los colores
  ". c #000000"
  "X c #ffffff",
  " c None",
  
  // píxels
  " ", //1
  " ",
  " ",
  " ",
  " ", //5
  " ",
  " ",
  " XXXXXX ",
  " XXXX X XXXX ",
  " XXX XXX ", //10
  " XX XX ",
  " X X X ",
  " X X X ",
  " X X X ",
  " XX XXXXXXXXXXX XX ", //15
  " X X X ",
  " X X X ",
  " X X X ",
  " X X X ",
  " XX XX ", //20
  " XXX XXX ",
  " XXXX X XXXX ",
  " XXXXXX ",
  " ",
  " ", //25
  " ",
  " ",
  " ",
  " ",
  " ", // 30
  " ",
  " ", // 32
  "0,0"
 };
 
 // Rellenamos la pantalla de un color diferente al negro
 Uint32 color = SDL_MapRGB(pantalla->format, 25, 100, 155);
 // Sólo en el rango que vamos a permitir para el ratón
 SDL_Rect delimitador;
 delimitador.x=100;
 delimitador.y=100;
 delimitador.w=440;
 delimitador.h=280;
 
 SDL_FillRect(pantalla, &delimitador, color);
 // Actualizamos la pantalla
 SDL_Flip(pantalla);
 // Guardamos el cursor original
 SDL_Cursor *original = SDL_GetCursor();
 
 SDL_Event evento;
 // Bucle "infinito"
 int ocultar=0;
 for ( ; ; ) {
  
  while (SDL_PollEvent(&evento)) {
   if (evento.type == SDL_KEYDOWN) {
    if (evento.key.keysym.sym == SDLK_ESCAPE) {
     SDL_FreeCursor(original);
    }
    return 0;
   }
  
   if (evento.type == SDL_QUIT){
    return 0;
   }
  
   // Movemos el ratón
   if (evento.type == SDL_MOUSEMOTION){
    if (evento.motion.x > 540 || evento.motion.x < 100 ||
     evento.motion.y > 380 || evento.motion.y < 100 ) {
     // Si se sale de este rango
     // Vuelve dentro de él
     cout << "Te has salido del rectángulo azul" << endl;
     SDL_WarpMouse(250, 200);
    }
    cout << "X: " << setw(3) << evento.motion.x << " - Y: " << setw(3) << evento.motion.y << endl;
   }
   
   // Pulsamos un botón del ratón
   if (evento.type == SDL_MOUSEBUTTONDOWN) {
    if (evento.button.button == 1) {
     cout << "X: " << setw(3) << evento.button.x << " - Y: " << setw(3) << evento.button.y
      << " Botón izquierdo pulsado, cursor personalizado" << endl;
     // Personalizamos el cursor
     SDL_Cursor *apuntador;
     apuntador = Cursor_personalizado_XPM(punto_mira);
     // Lo establecemos
     SDL_SetCursor(apuntador);
     // Nos aseguramos de que se muestra
     SDL_ShowCursor(1);
    } else if (evento.button.button == 2) {
     // Mostramos el cursor
     SDL_ShowCursor(1);
     // Reestablecemos el original
     SDL_SetCursor(original);
     cout << "Botón central, vuelta al cursor original" << endl;
    } else {
     // Ocultamos el cursor
     SDL_ShowCursor(ocultar);
     ocultar=!ocultar;
    }
   }
  }
 }
 cout << "Botón derecho pulsado, se oculta el cursor" << endl;
 return 0;
}

Desarrollo de videojuegos en SDL V

2013-10-24T23:54:00.000+02:00

Y nos vamos a los eventos en SDL, de Tutorial de libSDL para la programación de videojuegos.

La estructura principal es

typedef union{
Uint8 type;
SDL_ActiveEvent active; //tipo de evento
SDL_KeyboardEvent key;
SDL_MouseMotionEvent motion;
SDL_MouseButtonEvent button;
SDL_JoyAxisEvent jaxis;
SDL_JoyBallEvent jball;
SDL_JoyHatEvent jhat;
SDL_JoyButtonEvent jbutton;
SDL_ResizeEvent resize;
SDL_QuitEvent quit;
SDL_UserEvent user;
SDL_SysWMEvent syswm;
} SDL_Event;

Una breve explicación:

active: evento de activación. Informa de la situación del foco sobre la ventana.
key: evento producido por el teclado.
motion: evento producido por movimiento del ratón.
button: evento producido por el botón del ratón.
jaxis: evento de movimiento del eje del joystick.
jball: evento de movimiento del trackball del joystick.
jhat: evento de movimiento del minijoystick o hat del dispositivo.
jbutton: evento por botón del mando.
resize: evento por redimensionado de ventana.
quit: evento al cerrar aplicación.
user: evento definido por el usuario.
syswm: evento indefinido producido por el gestor de ventanas.

Formas de capturar eventos
Waiting: El programa espera por los eventos que se produzcan. Técnica muy utilizada en sistemas de gestión, donde no hay tareas en segundo plano, pero en juegos es poco útil.

int SDL_WaitEvent(SDL_Event *event);

Cuando se produce un evento, se rellenan los datos de event. Devuelve 1 si se ha copiado correctamente y eliminado de la lista de eventos. Cero al contrario. Si se pasa NULL, devuelve que ha pasado pero sin variar la cola.

Acceso directo al estado de eventos del dispositivo: Podemos acceder simbólicamente al hardware y leer el estado de un dispositivo discriminando la información con la idea de seleccionar sólo la que es relevante para nosotros. En realidad accedemos al sistema de eventos que es una capa superior a la de hardware que nos presenta la información para que podamos manejarla de forma cómoda.

Con éste método se peuden perder eventos. Cada vez que queramos consultar el estado, debemos actualizar primero con

void SDL_PumpEvents(void);

Polling:Técnica muy común, almacenamos los eventos en una cola para consultar en cualquier momento que deseemos (sondeo). SDL proporciona la cola.
Básicamente es comprobar si hay eventos, tratarlos si hay e ir haciendo otras tareas. Muy adecuado para videojuegos.

int SDL_PollEvent(SDL_Event *event);

Devuelve cero si no hay eventos pendientes, uno al contrario. Si le pasamos NULL, el evento no se elimina de la cola.

Teclado
El tipo de evento que muestra el teclado es SDL_KEYUP o SDL_KEYDOWN. Dentro de su estructura tiene un campo state, que resulta redundante, con los valores SDL_PRESSED y SDL_RELEASED.

typedef struct {
Uint8 type;
Uint8 state;
SDL_keysym keysym;
} SDL_KeyboardEvent;

keysym tiene la siguiente estructura:

typedef struct{
Uint8 scancode; //desaconsejado ya que depende del teclado y del sistema
SDL_Key sym; //tecla pulsada. Constantes SDL como SDL_a
SDLMod mod; //teclas especiales pulsadas (Ctrl, Alt, Shift)
Unit16 unicode; //por defecto no es rellenado
} SDL_Keysym;

Para que el campo unicode se rellene, se activa con:

int SDL_EnableUNICODE(int enable);

El cual devuelve el estado anterior al cambio.
0-Desactivado
1-Activado
2-sin cambio (para consulta)

En algunas aplicaciones es interesante que si pulsamos cierta tecla durante un tiemp, dicha letra oacción se repita varias veces. Para activar esta opción hemos de llamar a :

int SDL_EnableKeyRepeat(int delay, int interval);

La función devuelve cero si todo ha ido bien o -1 ante errores.
delay: tiempo que deve esperar antes de hacer efectiva la repetición.
interval: cada cuánto tiempo se repite.

Para ambos valores, SDL proporciona lo que a su juicio son valores adecuados. Se pueden obtener con las constantes SDL_DEFAULT_REPEAT_DELAY y SDL_DEFAULT_REPEAT_INTERVAL.

Si queremos acceder de forma directa al teclado y consultar su estado tenemos la función:

Uint8 *SDL_GetKeyState(int *numkeys);

El parámetro que recibe especifica el tamaño del vector que queremos obtener. Es habitual poner NULL como parámetro, lo que produce que la función nos devuelva el valor del estado para todas las teclas. Para consultar en el vector se usan las mismas constantes del campo sym. Si la tecla está pulsada, será 1, cero al contrario.

Para conocer el estado de las teclas modificadoras y forzar el estado de alguna de ellas tenemos

SDLMod SDL_GetModState(void);
void SDL_SetModState(SDLMod modstate);

Y por último, si queremos conocer el nombre de una tecla de forma humana, la siguiente función:

char *SDL_GetKeyName(SDLKey key);

Y hasta aquí hoy, es mucho. Unos cuantos pensaréis que estoy pasando el tutorial del pdf al blog, y en parte es cierto, ya avisé que esto no iba a ser una especie de clase, sino una especie de apuntes/resumen de lo que leo y aprendo. Y que sepáis que hasta aquí es la página 216 del tutorial, con lo que creo que lo resumo bastante jajaja.

Día 81

2013-10-24T23:50:00.002+02:00

Ya paso de decir nada sobre mi voluntad, lo que tardo en escribir, que si haré esto, lo otro... Tan solo seguiré. Y seguir, aquí sigo, tratando de repartir mi tiempo entre todo y he avanzado bastante. Hay cosas nuevas, cosas excitantes, buenos avances (dentro de lo que cabe).

Y el hecho de dejar para el final escribir las entradas, lo fastidia todo. Llego tan cansado del viaje que no soy capaz de plasmar aquí lo realmente sucedido en el día e incluso he dejado cosas para publicar mañana. Ya sé que es lo siguiente a cambiar.

Querido diario, no dejes que decaiga, no dejes que desaparezca la culpabilidad ni el malestar por no cumplir mi propia palabra... es ir directo al fracaso y parece como si desarrollar videojuegos no fuera mi sueño.

Código practica - bitmaps con SDL

2013-10-10T23:28:00.002+02:00

Dos códigos, dos simples mains, uno cargo una imagen bmp en pantalla y el otro más de lo mismo, base para todo videojuego que pueda hacer y que se honre con tal nombre. Hasta ahora no tengo nada que lleve ese nombre.
Peeero, estos códigos son imprescindibles para mi camino a recorrer. ^^

Lo único a tener en cuenta en el código es la ruta hacia la imagen que se muestra, que debe ser si o si bmp. (Según la definición del método, tampoco he probado).

main.c: Pulsa para ver/ocultar el código

#include <stdio.h>
#include <SDL/SDL.h>

//método auxiliar que uso
SDL_Surface *inicializacion();

int main(){
        //pantallas que uso
 SDL_Surface *pantalla, *imagen;
        //donde dibujaré
 SDL_Rect destino;
 
 //inicializo
 pantalla=inicializacion();
 
 if (pantalla == NULL) {
  printf("Error iniciando el entorno gráfico: %s\n", SDL_GetError());
  exit(1);
 }
 
        //cargo la imagen
 imagen = SDL_LoadBMP("images/sasuke.bmp");
 
 if(imagen==NULL){
  printf("Error al cargar la imagen: %s\n", SDL_GetError());
  exit(0);
 }
 
 // Guardamos el BMP con otro nombre
 if (SDL_SaveBMP(imagen, "images/sasuke2.bmp") == -1){
  printf("No se puede guardar la imagen\n");
 }
 
 // Inicializamos la variable de posición y tamaño de destino
 destino.x = 250;
 destino.y = 150; 
 destino.w = imagen->w;
 destino.h = imagen->h;
 
 // Copiamos la superficie creada rectángulo en la anterior pantalla
 SDL_BlitSurface(imagen, NULL, pantalla, &destino);

 // Mostramos la pantalla
 SDL_Flip(pantalla);

 // Ya podemos liberar el rectángulo, una vez copiado y mostrado
 SDL_FreeSurface(imagen);

 SDL_Delay(5000);
 exit(0);
}

SDL_Surface *inicializacion(){
 SDL_Surface *pantalla;
 if(SDL_Init(SDL_INIT_VIDEO)<0){
  printf("No se pudo iniciar SDL: %s\n", SDL_GetError());
  exit(1);
 }
 
 atexit(SDL_Quit);
 
 if(SDL_VideoModeOK(1024,768,24,SDL_SWSURFACE|SDL_DOUBLEBUF)==0){
  printf("Modo no soportado: %s\n", SDL_GetError());
  exit(1);
 }
 
 //saco la pantalla
 pantalla=SDL_SetVideoMode(1024, 768, 24, SDL_SWSURFACE|SDL_DOUBLEBUF);
 
 if (pantalla == NULL) {
  printf("Error iniciando el entorno gráfico: %s/n", SDL_GetError());
  exit(1);
 }
 
 return pantalla;
}

El otro código es el mismo main pero añadiendo el manejo del color key, siendo el magenta el que usé en mi imagen.

main.c: Pulsa para ver/ocultar el código

#include 
#include 

SDL_Surface *inicializacion();

int main(){
 SDL_Surface *pantalla, *imagen;
 SDL_Rect destino;
 
 //inicializo
 pantalla=inicializacion();
 
 if (pantalla == NULL) {
  printf("Error iniciando el entorno gráfico: %s\n", SDL_GetError());
  exit(1);
 }
 
 imagen = SDL_LoadBMP("images/sasuke.bmp");
 
 if(imagen==NULL){
  printf("Error al cargar la imagen: %s\n", SDL_GetError());
  exit(0);
 }
 
 // Inicializamos la variable de posición y tamaño de destino
 destino.x = 250;
 destino.y = 150; 
 destino.w = imagen->w;
 destino.h = imagen->h;
 
 //aplico transparencia
 Uint32 color=SDL_MapRGB(imagen->format, 255, 0, 255);
 SDL_SetColorKey(imagen, SDL_SRCCOLORKEY|SDL_RLEACCEL, color);
 
 // Copiamos la superficie creada rectángulo en la anterior pantalla
 SDL_BlitSurface(imagen, NULL, pantalla, &destino);

 // Mostramos la pantalla
 SDL_Flip(pantalla);

 // Ya podemos liberar el rectángulo, una vez copiado y mostrado
 SDL_FreeSurface(imagen);

 SDL_Delay(5000);
 exit(0);
}

SDL_Surface *inicializacion(){
 SDL_Surface *pantalla;
 if(SDL_Init(SDL_INIT_VIDEO)<0){
  printf("No se pudo iniciar SDL: %s\n", SDL_GetError());
  exit(1);
 }
 
 atexit(SDL_Quit);
 
 if(SDL_VideoModeOK(1024,768,24,SDL_HWSURFACE|SDL_DOUBLEBUF)==0){
  printf("Modo no soportado: %s\n", SDL_GetError());
  exit(1);
 }
 
 //saco la pantalla
 pantalla=SDL_SetVideoMode(1024, 768, 24, SDL_SWSURFACE|SDL_DOUBLEBUF);
 
 if (pantalla == NULL) {
  printf("Error iniciando el entorno gráfico: %s/n", SDL_GetError());
  exit(1);
 }
 
 return pantalla;
}