Juego de Serie en Clojure

Cuando quiero aprender un nuevo lenguaje desarrollo un juego de series, es decir aparece una serie con un valor faltante y el jugador debe completarlo.

Uno de los requerimientos no funcionales es que se pueda agregar una serie nueva fácilmente.

Vamos a desarrollar este juego en Clojure:

Empecemos desarrollo de la serie, la serie tiene como responsabilidad generarse y si lo hacemos de esta manera podemos utilizar la potencia del polimorfismo, para que no quede acoplado la generación de la serie con el desarrollo del juego:

(ns secuencia-clojure.core

  (:gen-class))

(import '(java.util Scanner))

(def scan (Scanner. *in*))

   

(defn generateSecEven []

  (def seed (rand-int 30))

  (for [x (range seed (+ seed 4))] (* x 2))

)

   

(defn generateSecOdd []

  (def seed (rand-int 30))

  (for [x (range seed (+ seed 4))] (+ (* x 2) 1))

)

(defn generateSecFibo []

  (def seed (rand-int 30))

  (def seed2 (* seed 2))

  (def seed3 (* seed 3))

  (list seed seed seed2 seed3)

)

Y listo!! ahora en el main tenemos que llamar a esta función y ver si esta bien el resultado: 

(defn generateSec []

  (def seed (rand-int 3))

  (cond 

    (= seed 0) (generateSecEven)

    (= seed 1) (generateSecOdd)

    (= seed 2) (generateSecFibo)   

  )

)

(defn printSec [sec]

  (print (nth sec 0))

  (print " ")

  (print (nth sec 1))

  (print " ")

  (print " __ ")

  (print " ")

  (println (nth sec 3))

)

(defn game

  [points]

  (def sec (generateSec))

  (def sol (nth sec 2))

  

  (printSec sec)

  

  (let [data (read-line)]

  (if (= data (str sol))

    (do 

      (println "Correct!! the point is " (str (+ points 1)))

      (game (+ points 1))

    )

    (do 

      (println "Wrong!! the point is " (str (- points 1)))

      (game (- points 1))

    )))

)

(defn -main

  [& args]

  (game 0))

Y eso es todo a jugar se a dicho!!

Dejo el repositorio git: 

https://github.com/emanuelpeg/secuenciaClojure

Juego de Serie en Rust

Cuando quiero aprender un nuevo lenguaje desarrollo un juego de series, es decir aparece una serie con un valor faltante y el jugador debe completarlo.

Uno de los requerimientos no funcionales es que se pueda agregar una serie nueva fácilmente.

Vamos a desarrollar este juego en Rust:

Empecemos desarrollo de la serie, la serie tiene como responsabilidad generarse y si lo hacemos de esta manera podemos utilizar la potencia del polimorfismo, para que no quede acoplado la generación de la serie con el desarrollo del juego:

use rand::{thread_rng, Rng};

pub fn iniciar_secuencia() -> [u16;4] {

let semilla:u8 = thread_rng().gen_range(0..3);

match semilla {

    0 => return generar_secuencia_par(),

    1 => return generar_secuencia_inpar(),

        _ => return generar_fibonacci()

}

}

//Esta función genera la serie y para eso utiliza diferentes funciones que generan diferentes tipos de secuencias : 

fn generar_secuencia_par() -> [u16;4] {

let mut resultado:[u16;4] = [0; 4];

let semilla:u16 = thread_rng().gen_range(0..30);

for i in 0..4 {

resultado[i] = semilla * 2 + (i as u16) * 2;

}

resultado

}

fn generar_secuencia_inpar() -> [u16;4] {

let mut resultado:[u16;4] = [0; 4];

let semilla:u16 = thread_rng().gen_range(0..30);

for i in 0..4 {

resultado[i] = semilla * 2 + (i as u16) * 2 + 1;

}

resultado

}

fn generar_fibonacci() -> [u16;4] {

let mut _resultado:[u16;4] = [0; 4];

let semilla:u16 = thread_rng().gen_range(0..30);

for i in 0..4 {

if i < 2 {

_resultado[i] = semilla;

} else {

_resultado[i] = _resultado[i-1] + _resultado[i-2];

}

}

_resultado

}

Y listo!! ahora en el main tenemos que llamar a esta función y ver si esta bien el resultado: 

use std::io;

use crate::serie::iniciar_secuencia;

mod serie;

fn main() {

    let mut puntos = 0u8;

    loop {

        let serie:[u16;4] = iniciar_secuencia();

        println!("Serie: ");

        

        for i in 0..2 {

            print!(" {} ", serie[i]);

        }

        println!("_____ {} ", serie[3]);

        println!("Ingrese el valor faltante: ");

        let mut input = String::new();

        io::stdin().read_line(&mut input).expect("error: unable to read user input");

        let x = input.trim().parse().expect("Error!! debe ser un numero.");

        

        if serie[2].eq(&x) {

            println!("Ganaste !! ");

            puntos = puntos + 1;

        } else {

            println!("Perdiste !! ");

        }

        println!("Puntos :  {} ", puntos);

        println!("Desea continuar jugando? (y/n): ");

        let mut continuar = String::new();

        io::stdin().read_line(&mut continuar).expect("error: unable to read user input");

        

        if continuar.trim().ne("y"){

            return;

        }

    }    

}

Y eso es todo a jugar se a dicho!!

Dejo el repositorio git: https://github.com/emanuelpeg/secuenciaRust

Juego de Serie en Go

Cuando quiero aprender un nuevo lenguaje desarrollo un juego de series, es decir aparece una serie con un valor faltante y el jugador debe completarlo.

Uno de los requerimientos no funcionales es que se pueda agregar una serie nueva fácilmente, para cumplirlo vamos a utilizar las ventajas de go.

Empecemos desarrollo de la serie, la serie tiene como responsabilidad generarse :

func IniciarSecuencia() [4]int {

rand.Seed(time.Now().Unix())

semilla := rand.Intn(3)

switch semilla {

case 0:

return generarSecuenciaPar()

case 1:

return generarSecuenciaInpar()

default:

return generarFibonacci()

}

}

Esta función genera la serie y para eso utiliza diferentes funciones que generan diferentes tipos de secuencias : 

import (

"math/rand"

"time"

)

func generarSecuenciaPar() [4]int {

var resultado [4]int

rand.Seed(time.Now().Unix())

semilla := rand.Intn(100)

for i := 0; i < 4; i++ {

resultado[i] = semilla + i*2

}

return resultado

}

func generarSecuenciaInpar() [4]int {

var resultado [4]int

rand.Seed(time.Now().Unix())

semilla := rand.Intn(100)

for i := 0; i < 4; i++ {

resultado[i] = semilla + i*2 + 1

}

return resultado

}

func generarFibonacci() [4]int {

var resultado [4]int

rand.Seed(time.Now().Unix())

semilla := rand.Intn(50)

for i := 0; i < 4; i++ {

if i < 2 {

resultado[i] = semilla

} else {

resultado[i] = resultado[i-1] + resultado[i-2]

}

}

return resultado

}

Y listo!! ahora en el main tenemos que llamar a esta función y ver si esta bien el resultado: 

package main

import (

"example/secuencia/secuencia/model"

"fmt"

"os"

)

func main() {

fmt.Println("------------- Bienvenido !! ----------------")

exit := 'Y'

puntaje := 0

for exit != 'N' {

secuencia := model.IniciarSecuencia()

for i := 0; i < len(secuencia); i++ {

if i != 2 {

fmt.Print(secuencia[i])

fmt.Print(" ")

} else {

fmt.Print("________  ")

}

}

fmt.Println()

fmt.Println("--------------------------")

fmt.Print(" Faltante :")

var nro int

n, err := fmt.Scanf("%d\n", &nro)

if err != nil {

fmt.Println(n, err)

os.Exit(n)

}

if nro == secuencia[2] {

fmt.Print(" Ganaste!! ")

puntaje++

} else {

fmt.Print(" Perdiste!! ")

puntaje--

}

fmt.Println(" Puntaje : ", puntaje)

fmt.Print(" Desea continuar jugando ? (Y/N) ")

fmt.Scanf("%c\n", &exit)

}

}

Y eso es todo a jugar se a dicho!!

Dejo el repositorio git: https://github.com/emanuelpeg/secuenciaGolang 

Juego de Serie en C# con .net core

Cuando quiero aprender un nuevo lenguaje desarrollo un juego de series, es decir aparece una serie con un valor faltante y el jugador debe completarlo.

Uno de los requerimientos no funcionales es que se pueda agregar una serie nueva fácilmente, para cumplirlo vamos a utilizar las ventajas de herencia y polimorfismo.

Vamos a desarrollar este juego en C# para ello creamos el proyecto con : 

$ dotnet new console -lang C#

Luego de esto abrimos nuestro editor favorito, podemos utilizar visual code.  

Empecemos desarrollo de la serie, la serie tiene como responsabilidad generarse y si lo hacemos de esta manera podemos utilizar la potencia del polimorfismo, para que no quede acoplado la generación de la serie con el desarrollo del juego:

using System;

namespace dotNetSecuencia.model

{

    public abstract class Secuencia

    {

        protected int[] nros = new int[4];

        public Secuencia() {

            this.generar();

        }

        public int[] Nro {

            get {

                return nros;

            }

        }

        

        public abstract void generar();

    }

}

Ahora vamos a ver las implementaciones de secuencia:

using System;

namespace dotNetSecuencia.model

{

    public class SecuenciaPar : Secuencia

    {        

        public override void generar() {

            int semilla = new Random ().Next (99) * 2;

            for (int i = 0; i<4; i++) {

                this.nros[i] = (semilla + i * 2); 

            }

        }

    }

}

Y ahora la secuencia Impar: 

using System;

namespace dotNetSecuencia.model

{

    public class SecuenciaImpar : Secuencia

    {

        public override void generar() {

            int semilla = new Random ().Next (99) * 2;

            for (int i = 0; i<4; i++) {

                this.nros[i] = (semilla + i * 2) + 1; 

            }

        }

    }

}

Y ahora la secuencia Fibonacci :

using System;

namespace dotNetSecuencia.model

{

    public class SecuenciaFibonacci : Secuencia

    {

        public override void generar() {

            int until = new Random ().Next (15);

            this.nros[0] = 0;

            this.nros[1] = 1;

            this.nros[2] = 1;

            this.nros[3] = 2;

            for (int i = 0; i<until; i++) {

                 this.nros[0] = this.nros[1];

                 this.nros[1] = this.nros[2];

                 this.nros[2] = this.nros[3];

                 this.nros[3] = this.nros[1] + this.nros[2];

            }

        }

    }

}

Ahora vamos a ver el juego, este tiene la responsabilidad de verificar si el usuario acertó y tambien debe llevar los puntos: 

 using System;

namespace dotNetSecuencia.model

{

    public class Juego

    {

        private int puntaje = 0;

        private Secuencia secuencia = null;

        public Juego() 

        {

            this.generarSecuencia();

        }

        public int Nro1 {

            get {

                return this.secuencia.Nro[0];

            }

        }

        public int Nro2 {

            get {

                return this.secuencia.Nro[1];

            }

        }

        public int Nro4 {

            get {

                return this.secuencia.Nro[3];

            }

        }

        public int Puntaje {

            get {

                return this.puntaje;

            }

        }

        public void generarSecuencia() 

        {

            int semilla = new Random ().Next (3);

            switch (semilla)

            {

                case 0 :

                    this.secuencia = new SecuenciaPar(); 

                break;

                case 1 :

                    this.secuencia = new SecuenciaImpar(); 

                break;

                default:

                    this.secuencia = new SecuenciaFibonacci();

                break;

            }

        }

        public bool isOk(int valor) {

            bool result = false;

            if (this.secuencia.Nro[2] == valor) {

                this.puntaje++;

                result = true;

            } else {

                this.puntaje--;

            }

            this.generarSecuencia();

            return result;

        }

    }

}

Ahora programemos la interfaz por consola por supuesto : 

using System;

using dotNetSecuencia.model;

namespace dotNetSecuencia

{

    class Program

    {

        static void Main(string[] args)

        {

            Console.WriteLine("Bienvenido !!");

            Juego juego = new Juego();

            String respuestaStr;

            do {

                Console.WriteLine("La secuencia es : ");

                Console.WriteLine(" " + juego.Nro1 + " " + juego.Nro2 + "  __  " + juego.Nro4 );

                respuestaStr = Console.ReadLine();

                int respuesta = Convert.ToInt32(respuestaStr);

                if (juego.isOk(respuesta)) {

                    Console.WriteLine("Ganaste!! Tu puntaje es " + juego.Puntaje);

                } else {

                    Console.WriteLine("Perdiste!! Tu puntaje es " + juego.Puntaje);

                }

                Console.WriteLine("Quieres seguir Jugando [n/s] ? ");

                respuestaStr = Console.ReadLine();

            } while (respuestaStr != "n");

        }

    }

}

Y eso es todo!!! a jugar se a dicho!!

Dejo el repositorio git: 

https://github.com/emanuelpeg/secuenciaCSharp

Juego de Serie en Crystal

Cuando quiero aprender un nuevo lenguaje desarrollo un juego de series, es decir aparece una serie con un valor faltante y el jugador debe completarlo.

Uno de los requerimientos no funcionales es que se pueda agregar una serie nueva fácilmente, para cumplirlo vamos a utilizar las ventajas de herencia y polimorfismo.

Vamos a desarrollar este juego en Crystal :

Comencemos haciendo un nuevo proyecto:

crystal init app secuenciaCrystal
cd secuenciaCrystal

y luego probamos compilar :

shards build

Y todo debería funcionar. 

Ahora utilizaremos visual code con un plugin para crystal, para importar el proyecto, vamos a abrir carpeta y seleccionamos la carpeta donde estamos trabajando : 

Ahora vamos a hacer un archivo secuencia.cr que va a tener las clases de secuencias:


abstract class Secuencia

  @secuencia : Array(Int32)

  getter secuencia

  def initialize()
    @secuencia = generarSecuencia()
  end

  abstract def generarSecuencia() : Array(Int32)

end

class SecuenciaPar < Secuencia

  def generarSecuencia() : Array(Int32)
     Array(Int32).new(4) { |i|
       i * 2 * rand(100) + rand(10) * 2
     }

  end

end

class SecuenciaInPar < Secuencia

  def generarSecuencia() : Array(Int32)
    Array(Int32).new(4) { |i|
       i * 2 * rand(100) + rand(10) * 2 + 1
    }
  end

end

Luego hacemos otro archivo para juego:

require "./secuencia.cr"

class Juego

  getter puntos

  @secuencia : Secuencia

  def initialize()
    @puntos = 0
    @secuencia = generarSecuencia()
  end

  def generarSecuencia() : Secuencia
    i = rand(2)

    case i
        when 0
          SecuenciaPar.new
        else
          SecuenciaInPar.new
    end
  end

  def valor1()
    @secuencia.secuencia[0]   
  end

  def valor2()
    @secuencia.secuencia[1]   
  end

  def valor4()
    @secuencia.secuencia[3]   
  end

  def esta_bien?(num : Int32?) : Bool
    if @secuencia.secuencia[2] == num
       @puntos = @puntos + 1
       @secuencia = generarSecuencia()
       true
    else
       @puntos = @puntos - 1
       @secuencia = generarSecuencia()
       false
    end
  end

end

Y por ultimo tenemos el programa propiamente dicho:

require "./secuenciaCrystal/*"
require "./juego.cr"


module SecuenciaCrystal
  puts "Bienvenido a Secuancia Crystal"
  juego = Juego.new
  while true
    puts juego.valor1.to_s + " " + juego.valor2.to_s + " ______ " + juego.valor4.to_s + " \n"
    puts "Ingere el valor \n"
   
    valorStr = gets.to_s
   
    valor = (valorStr).to_i32

    if juego.esta_bien?(valor)
      puts " Ganaste !! Tus puntos : " + juego.puntos.to_s
    else
      puts " Perdiste !! Tus puntos : " + juego.puntos.to_s
    end
    puts "Ingere 0 para salir y otro valor para continuar"
    if gets()  == "0"
      break
    end

  end
  puts "Bye!"
end

Como se puede apreciar el diseño del juego permite generar una interfaz de consola o gráfica o en otra tecnología esta es la mayor ventaja de separar nuestros objetos de la capa de presentación.

Funcionando es muy divertido:

Dejo el repo: https://github.com/emanuelpeg/secuenciaCrystal

Juego de Serie en C# y mono!!

Cuando quiero aprender un nuevo lenguaje desarrollo un juego de series, es decir aparece una serie con un valor faltante y el jugador debe completarlo.

Uno de los requerimientos no funcionales es que se pueda agregar una serie nueva fácilmente, para cumplirlo vamos a utilizar las ventajas de herencia y polimorfismo.

Vamos a desarrollar este juego en C# y mono :

Empecemos desarrollo de la serie, la serie tiene como responsabilidad generarse y si lo hacemos de esta manera podemos utilizar la potencia del polimorfismo, para que no quede acoplado la generación de la serie con el desarrollo del juego:

using System;
using System.Collections.Generic;

namespace SecuenciaCSharep
{
public abstract class Secuencia
{
protected IList<int> values = new List<int>();

protected abstract void generate();

public Secuencia ()
{
this.generate();
}

public IList<int> getValues(){
return values;
}

}
}

Ahora vamos a ver las implementaciones de secuencia:

using System;

namespace SecuenciaCSharep

{

public class SecuenciaPar : Secuencia

{

protected override void generate () {

int semilla = new Random ().Next (99);

for (int i = 0; i<4; i++) {

this.values.Add (semilla * i * 2);

}

}

public SecuenciaPar ()

{

}

}

}

Y ahora la secuencia Impar: 

using System;

namespace SecuenciaCSharep

{

public class SecuenciaInPar : Secuencia

{

protected override void generate () {

int semilla = new Random ().Next (99);

for (int i = 0; i<4; i++) {

this.values.Add ((semilla * i * 2) + 1);

}  

}

public SecuenciaInPar ()

{

}

}

}

Ahora vamos a ver el juego, este tiene la responsabilidad de verificar si el usuario acertó y tambien debe llevar los puntos: 

using System;

namespace SecuenciaCSharep

{

public class Juego

{

private Secuencia secuencia;

private int puntaje = 0;

public void generar() {

int i = new Random ().Next (2);

switch (i) {

case 0:

secuencia = new SecuenciaPar ();

break;

default: 

secuencia = new SecuenciaInPar ();

break;

}

}

public Juego ()

{

this.puntaje = 0;

generar ();

}

public int getValue0() {

return secuencia.getValues()[0];

}

public int getValue1() {

return secuencia.getValues()[1];

}

private int getValue2() {

return secuencia.getValues()[2];

}

public int getValue3() {

return secuencia.getValues()[3];

}

public int getPuntaje() {

return this.puntaje;

}

public bool isOK(int n) {

if (this.getValue2 () == n) {

this.puntaje++;

this.generar ();

return true;

}

this.puntaje --;

this.generar ();

return false;

}

}

}

Ahora programemos la interfaz en este caso utilizaremos mono+Gtk:

using System;

using Gtk;

using SecuenciaCSharep;

public partial class MainWindow: Gtk.Window

{

private Juego juego;

public MainWindow (): base (Gtk.WindowType.Toplevel)

{

Build ();

juego = new Juego ();

this.regenerate ();

}

protected void OnDeleteEvent (object sender, DeleteEventArgs a)

{

Application.Quit ();

a.RetVal = true;

}

protected void OnButton1Clicked (object sender, EventArgs e)

{

int n = (int)this.spinbutton2.Value;

MessageDialog msd; 

if (juego.isOK (n)) {

msd = new MessageDialog (this, DialogFlags.Modal, MessageType.Info, ButtonsType.None, "Ganaste!! Puntaje : " + juego.getPuntaje());

} else {

msd = new MessageDialog (this, DialogFlags.Modal, MessageType.Info, ButtonsType.None, "Perdiste  Puntaje : " + juego.getPuntaje());

}

msd.Show ();

this.regenerate ();

}

private void regenerate() {

this.label1.Text = juego.getValue0 ().ToString();

this.label2.Text = juego.getValue1 ().ToString();

this.label3.Text = juego.getValue3 ().ToString();

this.spinbutton2.Value = 0;

}

}

Y eso es todo!!! a jugar se a dicho!!

Dejo el repositorio git: 

https://github.com/emanuelpeg/serieCSharp

Juego de Serie en c++ con QT

Vamos a tomar el juego : http://emanuelpeg.blogspot.com.ar/2017/10/juego-de-serie-en-c.html y lo llevaremos a qt.

Para eso debemos hacer un nuevo proyecto qt y llevar nuestras clases. Y ahora vamos a programar las pantallas, Vamos a hacer una ventana que se llame MainWindows (original lo mio) :

MainWindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include "juego.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();


private slots:
    void on_pushButton_clicked();

private:
    Ui::MainWindow *ui;
    Juego juego;
    void dibujar();
};

#endif // MAINWINDOW_H

Como vemos hemos agregado una propiedad de tipo juego. Veamos el cpp : 

#include "mainwindow.h"

#include "ui_mainwindow.h"

#include <QMessageBox>

#include <QString>

MainWindow::MainWindow(QWidget *parent) :

    QMainWindow(parent),

    ui(new Ui::MainWindow)

{

    ui->setupUi(this);

    this->dibujar();

}

MainWindow::~MainWindow()

{

    delete ui;

}

void MainWindow::dibujar() {

    ui->label->setText(QString::number(juego.getValor0()));

    ui->label_2->setText(QString::number(juego.getValor1()));

    ui->label_3->setText(QString::number(juego.getValor3()));

    ui->spinBox->setValue(0);

}

void MainWindow::on_pushButton_clicked()

{   QString msg;

    if (juego.validar(ui->spinBox->value())) {

        msg = "ganaste  Puntaje:"+ QString::number(juego.getPuntos());

    } else {

        msg = "perdio Puntaje:"+ QString::number(juego.getPuntos());

    }

    QMessageBox::warning(this, tr("Resultado"),

                                       msg,

                                       QMessageBox::Ok  ,

                                       QMessageBox::Ok);

    this->dibujar();

}

Ya se no se entiende bien por que falta el diseño de la pantalla : 

<?xml version="1.0" encoding="UTF-8"?>

<ui version="4.0">

 <class>MainWindow</class>

 <widget class="QMainWindow" name="MainWindow">

  <property name="geometry">

   <rect>

    <x>0</x>

    <y>0</y>

    <width>496</width>

    <height>105</height>

   </rect>

  </property>

  <property name="windowTitle">

   <string>Secuencia</string>

  </property>

  <widget class="QWidget" name="centralWidget">

   <layout class="QHBoxLayout" name="horizontalLayout">

    <item>

     <widget class="QLabel" name="label">

      <property name="text">

       <string>TextLabel</string>

      </property>

     </widget>

    </item>

    <item>

     <widget class="QLabel" name="label_2">

      <property name="text">

       <string>TextLabel</string>

      </property>

     </widget>

    </item>

    <item>

     <widget class="QSpinBox" name="spinBox">

      <property name="minimum">

       <number>-9999999</number>

      </property>

      <property name="maximum">

       <number>9999999</number>

      </property>

     </widget>

    </item>

    <item>

     <widget class="QLabel" name="label_3">

      <property name="text">

       <string>TextLabel</string>

      </property>

     </widget>

    </item>

    <item>

     <widget class="QPushButton" name="pushButton">

      <property name="text">

       <string>verificar</string>

      </property>

     </widget>

    </item>

   </layout>

  </widget>

  <widget class="QMenuBar" name="menuBar">

   <property name="geometry">

    <rect>

     <x>0</x>

     <y>0</y>

     <width>496</width>

     <height>25</height>

    </rect>

   </property>

  </widget>

  <widget class="QToolBar" name="mainToolBar">

   <attribute name="toolBarArea">

    <enum>TopToolBarArea</enum>

   </attribute>

   <attribute name="toolBarBreak">

    <bool>false</bool>

   </attribute>

  </widget>

  <widget class="QStatusBar" name="statusBar"/>

 </widget>

 <layoutdefault spacing="6" margin="11"/>

 <resources/>

 <connections/>

</ui>

Ahora si, como vemos agregamos unos labels que muestran los números y un spinBox que permite ingresar números. Y luego con un botón los validamos. 

Como se puede apreciar el diseño del juego permite generar una interfaz de consola o en qt o en otra tecnología esta es la mayor ventaja de separar nuestros objetos de la capa de presentación. 

Dejo el repositorio git: https://github.com/emanuelpeg/secuanciaQt 

Juego de Serie en c++

Cuando quiero aprender un nuevo lenguaje desarrollo un juego de series, es decir aparece una serie con un valor faltante y el jugador debe completarlo.

Uno de los requerimientos no funcionales es que se pueda agregar una serie nueva fácilmente, para cumplirlo vamos a utilizar las ventajas de herencia y polimorfismo.

Vamos a desarrollar este juego en C++:

Empecemos desarrollo de la serie, la serie tiene como responsabilidad generarse y si lo hacemos de esta manera podemos utilizar la potencia del polimorfismo, para que no quede acoplado la generación de la serie con el desarrollo del juego:

Vamos a dividir nuestros archivos en .h y .cpp empecemos con secuencia.h :

#ifndef SECUENCIA_H
#define SECUENCIA_H

class Secuencia
{
protected:
    int valores[4];
public:
    Secuencia();
    virtual void generarValores()=0;
    int getValor(int index);
};

#endif // SECUENCIA_H

secuencia.cpp :

#include "secuencia.h"

Secuencia::Secuencia()

{

    for(int i=0;i<4; i++){

        valores[i]=0;

    }

}

int Secuencia::getValor(int index){

    return valores[index];

}

Ahora vamos a ver las implementaciones de secuencia, veamos secuenciapar.h :

#ifndef SECUENCIAPAR_H

#define SECUENCIAPAR_H

#include "secuencia.h"

class SecuenciaPar:public Secuencia

{

public:

    SecuenciaPar();

    void generarValores();

};

#endif // SECUENCIAPAR_H

secuenciapar.cpp :

#include "secuenciapar.h"

#include <stdlib.h>

#include <time.h>

SecuenciaPar::SecuenciaPar()

{

}

void SecuenciaPar::generarValores(){

    srand(time(NULL));

    int par = (rand() % 100) * 2;

    srand(time(NULL));

    int par2 = (rand() % 50) * 2;

    for(int i = 0; i<4; i++){

        valores[i] = par + (par2 * i);

    }

}

secuenciaimpar.h :

#ifndef SECUENCIAIMPAR_H

#define SECUENCIAIMPAR_H

#include "secuencia.h"

class SecuenciaImpar:public Secuencia

{

public:

    SecuenciaImpar();

    void generarValores();

};

#endif // SECUENCIAIMPAR_H

secuenciaimpar.cpp :

#include "secuenciaimpar.h"

#include <stdlib.h>

#include <time.h>

SecuenciaImpar::SecuenciaImpar()

{

}

void SecuenciaImpar::generarValores(){

    srand(time(NULL));

    int par = ((rand() % 100) * 2)+1;

    srand(time(NULL));

    int par2 = ((rand() % 50) * 2);

    for(int i = 0; i<4; i++){

        valores[i] = par + (par2 * i);

    }

}

Ahora vamos a ver el juego, este tiene la responsabilidad de verificar si el usuario acertó y tambien debe llevar los puntos: 

#ifndef JUEGO_H

#define JUEGO_H

#include "secuencia.h"

class Juego

{

private:

    int puntos;

    Secuencia * secuencia;

    void regenerar();

public:

    Juego();

    int getValor0();

    int getValor1();

    int getValor3();

    bool validar(int numero);

    int getPuntos();

};

#endif // JUEGO_H

juego.cpp :

#include "juego.h"

#include "secuenciapar.h"

#include "secuenciaimpar.h"

#include <stdlib.h>

#include <time.h>

Juego::Juego()

{

    secuencia = 0;

    this->puntos = 0;

    this->regenerar();

}

void Juego::regenerar() {

    if (secuencia != 0) delete secuencia;

    srand(time(NULL));

    int aleatorio = (rand() % 2);

    switch (aleatorio) {

    case 0:

        secuencia = new SecuenciaPar();

        break;

    default:

        secuencia = new SecuenciaImpar();

        break;

    }

    secuencia->generarValores();

}

int Juego::getValor0(){

    return this->secuencia->getValor(0);

}

int Juego::getValor1(){

    return this->secuencia->getValor(1);

}

int Juego::getValor3(){

    return this->secuencia->getValor(3);

}

bool Juego::validar(int numero) {

    bool resultado = false;

    if (numero == this->secuencia->getValor(2)) {

        this->puntos++;

        resultado = true;

    } else {

        this->puntos--;

    }

    this->regenerar();

    return resultado;

}

int Juego::getPuntos(){

    return this->puntos;

}

Ahora programemos la interfaz en este caso utilizaremos la consola:

#include <iostream>

#include <stdlib.h>

#include "juego.h"

using namespace std;

int main()

{

    Juego juego;

    cout << " ========== BIENVENIDO =========== "<<endl;

    cout << endl;

    while (true) {

        cout << " La secuencia es : "<<endl;

        cout << "                    " << juego.getValor0() << "   " ;

        cout << juego.getValor1() << "   ?   " << juego.getValor3()<<endl;

        int valor = 0;

        cout << "                               ";

        cin >> valor;

        if  (juego.validar(valor)) {

            cout << "     Ganaste!!  :D "<< endl;

        } else {

            cout << "     Perdiste   :(  "<< endl;

        }

        cout << endl << "     Sus puntos son :  " << juego.getPuntos() << endl;

        cout << "     Desea continuar jugando ? (y/n)  ";

        char opt;

        cin >> opt;

        if (opt == 'n') return 0;

           else cout << endl << endl;

    }

}

Y eso es todo a jugar se a dicho!!

Dejo el repositorio git: https://github.com/emanuelpeg/SerieCpp

Juego de Serie en Scala

Cuando quiero aprender un nuevo lenguaje desarrollo un juego de series, es decir aparece una serie con un valor faltante y el jugador debe completarlo.

Uno de los requerimientos no funcionales es que se pueda agregar una serie nueva fácilmente, para cumplirlo vamos a utilizar las ventajas de herencia y polimorfismo.

Vamos a desarrollar este juego en scala:

Empecemos desarrollo de la serie, la serie tiene como responsabilidad generarse y si lo hacemos de esta manera podemos utilizar la potencia del polimorfismo, para que no quede acoplado la generación de la serie con el desarrollo del juego:

package com.blog.serie

import scala.util.Random

abstract class Serie {

  var semilla = Random.nextInt(2000) + 1;

  def generate(): Seq[Int];

  val serie : Seq[Int]= generate();

}

Luego implementemos las series:

package com.blog.model.serie

import scala.util.Random

/**
 * @author emanuel
 *
 */
class SeriePar extends Serie {

  override def generate(): Seq[Int] = for(i <- 0 to 3) yield (i + semilla) * 2

}

Una serie impar:

package com.blog.model.serie

import scala.util.Random
import scala.collection.immutable.List

/**
 * @author emanuel
 *
 */
class SerieImpar extends Serie {

  override def generate(): Seq[Int] =
    for(i <- 0 to 3) yield if ((semilla%2)==0) (i * 2) + semilla + 1 else (i * 2) + semilla

}

Serie normal

package com.blog.model.serie

import scala.util.Random

class SerieNormal extends Serie {

  override def generate(): Seq[Int] = for(i <- 0 to 3) yield (i + semilla)

}

Serie de fibonacci;

package com.blog.model.serie

import scala.util.Random

/**
 * @author emanuel
 *
 */
class SerieFibonacci extends Serie {

 override def generate(): Seq[Int] =  {
   semilla = Random.nextInt(20) + 1
 
   def fibo(n:Int) : Int = n match {
     case 0 => 1
     case 1 => 1
     case _ => fibo(n-1) + fibo(n-2)
   }
 
   for(i <- 0 to 3) yield fibo(i + semilla)
 }

}

Ya tenemos un conjunto interesante de series, ahora a programar el juego:

package com.blog.model

import com.blog.model.serie._
import scala.util.Random

class Juego {

  var serie : Serie = null
  var puntos = 0

  def generarSerie():Unit = {
    val selector = Random.nextInt(4);
 
    selector match {
      case 0 => serie = new SerieNormal()
      case 1 => serie = new SeriePar()
      case 2 => serie = new SerieFibonacci()
      case _ => serie = new SerieImpar()
    }
  }

  generarSerie()

  def getValor0() = serie.serie.seq(0)
  def getValor1() = serie.serie.seq(1)
  def getValor3() = serie.serie.seq(3)

  def isValid(i: Int):Boolean =
    if (i == serie.serie.seq(2)) {
       puntos= puntos+1
       generarSerie()
       true
    } else {
      generarSerie()
      false
    }

}

El Juego es el encargado de crear la serie, mostrar los valores y validar si la respuesta es correcta. Ahora programemos la interfaz en este caso utilizaremos la consola:

package com.blog.model


object Principal extends App {

  var juego = new Juego
  var op = "ok"

  while (op == "ok") {

    println("Serie " + juego.getValor0() + " , "+ juego.getValor1() + " ___ " + juego.getValor3())
    println()
    print(" Indique el valor faltante : ")
    val i = readInt()
 
    if (juego.isValid(i)) {
      println(" Ganaste !! Puntaje : " + juego.puntos)
    } else {
      println(" Perdiste !! Puntaje : " + juego.puntos)
    }
 
    println(" Si desea continuar ingrese ok : ")
    op = readLine()

  }

  println(" chau !! ")

}

Y eso es todo a jugar se a dicho!!

Dejo el repositorio git: https://github.com/emanuelpeg/serieScala