martes, 31 de marzo de 2015

Mapa de tiles en SFML


Descargar Assets para este proyecto


TileMap.h

#include <SFML\Graphics.hpp>

class TileMap : public sf::Drawable, public sf::Transformable
{
public:

 bool load(const std::string& tileset, sf::Vector2u tileSize, const int* tiles, unsigned int width, unsigned int height)
 {
  // Cargamos la textura del tile
  if (!m_tileset.loadFromFile(tileset))
   return false;

  // Establecemos la forma del vertex array y le pasamos el ancho y el alto del tile por la cantidad de tiles que contiene la imagen en este caso 4
  m_vertices.setPrimitiveType(sf::Quads);
  m_vertices.resize(width * height * 4);

  // rellenamos el vertex array con un quad por cada tile
  for (unsigned int i = 0; i < width; ++i)
   for (unsigned int j = 0; j < height; ++j)
   {
    // obtenemos el numero de tile actual
    int numeroTile = tiles[i + j * width];

    // encontramos la posicion del tileset para partirlo
    int tu = numeroTile % (m_tileset.getSize().x / tileSize.x);
    int tv = numeroTile / (m_tileset.getSize().x / tileSize.x);

    // Apuntamos al quad actual mediante un puntero
    sf::Vertex* quad = &m_vertices[(i + j * width) * 4];

    // definimos las posiciones del quad
    quad[0].position = sf::Vector2f(i * tileSize.x, j * tileSize.y);
    quad[1].position = sf::Vector2f((i + 1) * tileSize.x, j * tileSize.y);
    quad[2].position = sf::Vector2f((i + 1) * tileSize.x, (j + 1) * tileSize.y);
    quad[3].position = sf::Vector2f(i * tileSize.x, (j + 1) * tileSize.y);

    // definimos las coordenadas del quad
    quad[0].texCoords = sf::Vector2f(tu * tileSize.x, tv * tileSize.y);
    quad[1].texCoords = sf::Vector2f((tu + 1) * tileSize.x, tv * tileSize.y);
    quad[2].texCoords = sf::Vector2f((tu + 1) * tileSize.x, (tv + 1) * tileSize.y);
    quad[3].texCoords = sf::Vector2f(tu * tileSize.x, (tv + 1) * tileSize.y);
   }

  return true;
 }

private:

 virtual void draw(sf::RenderTarget& target, sf::RenderStates states) const
 {
  // lo transformamos
  states.transform *= getTransform();

  // pasamos la textura
  states.texture = &m_tileset;

  // dibujamos el vertex array
  target.draw(m_vertices, states);
 }

 sf::VertexArray m_vertices;
 sf::Texture m_tileset;
};


Main.cpp

#include "TileMap.h"
int main()
{
 // Creamos la ventana
 sf::RenderWindow window(sf::VideoMode(800, 600), "Tilemap");

 // Definimos un arreglo que contendra el numero de tile
 const int level[] =
 {
  0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0,
  1, 1, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 3,
  0, 1, 0, 0, 2, 0, 3, 3, 3, 0, 1, 1, 1, 0, 0, 0,
  0, 1, 1, 0, 3, 3, 3, 0, 0, 0, 1, 1, 1, 2, 0, 0,
  0, 0, 1, 0, 3, 0, 2, 2, 0, 0, 1, 1, 1, 1, 2, 0,
  2, 0, 1, 0, 3, 0, 2, 2, 2, 0, 1, 1, 1, 1, 1, 1,
  0, 0, 1, 0, 3, 2, 2, 2, 0, 0, 0, 0, 1, 1, 1, 1,
  0, 0, 1, 0, 3, 2, 2, 2, 0, 0, 0, 0, 1, 1, 1, 1,
  0, 0, 1, 0, 3, 2, 2, 2, 0, 0, 0, 0, 1, 1, 1, 1,
 };

 // Creamos un objeto de tipo Tilemap
 TileMap map;

 //Mandamos a llamar a la figura con tiles, la cual son de 64 * 64 cada tile y colocaremos tiles 16 horizontales y 10 verticales

 //los parametros que pasamos son el nombre de la textura, los tamaños individuales de las texturas
 //el arreglo y los indices del arreglo
 if (!map.load("tilemap.png", sf::Vector2u(64, 64), level, 16, 10))
  return -1;

 // Inicia el GameLoop
 while (window.isOpen())
 {
  //ponemos la ventana de color blanco
  window.clear( sf :: Color :: White );

  //dibujamos el mapa
  window.draw(map);

  // Evento cerrar
  sf::Event event;
  while (window.pollEvent(event))
  {
   if (event.type == sf::Event::Closed)
    window.close();
  }

  window.display();
 }

 return 0;
}








Practica siempre para ir mejorando, la repetición y la constancia nos ayudan a mejorar, recuerda cada vez lo harás mejor, si te equivocas esta bien, permitirse equivocarse es la clave de mejora continua, así que permítete equivocarte mas seguido.

Si te gusta este sitio y deseas que esto continué vivo tu apoyo sera importante, puedes dar clic en la publicidad si lo deseas o puedes donar algo en Patreon si puedes permitírtelo, con esto el proyecto empezara a tener un objetivo y dejara de navegar sin rumbo y empezara a convertirse en una comunidad que ayudara unos a los otros, saludos y excelente día.

Sistema de Particulas en SFML


SistemaParticulas.h

#include <SFMLGraphics.hpp>

class SistemaParticulas : public sf :: Drawable , public sf :: Transformable
{
public:

 SistemaParticulas(unsigned int cantidad) : mParticulas(cantidad), mVertices(sf::Points, cantidad),
  mTiempoDeVida(sf::seconds(3)), mEmision(0, 0)
 {

 }

 void setEmision( sf :: Vector2f posicion )
 {
  mEmision = posicion;
 }

 void update(sf::Time tiempoTranscurrido)
 {
  for (std::size_t i = 0; i < mParticulas.size(); ++i)
  {
   //Actualiza el ciclo de vida de las particulas
   Particula &p = mParticulas[i];
   p.tiempoDeVida -= tiempoTranscurrido;

   //Si la particula esta muerta remplazala
   if (p.tiempoDeVida <= sf::Time::Zero)
   {
    resetParticula( i );
   }

   //Actualiza la posicion del del vertex correspondiente
   mVertices[i].position += p.velocidad * tiempoTranscurrido.asSeconds();

   //Actualiza el alpha o transparencia de la particula mientras esta viva
   float rango = p.tiempoDeVida.asSeconds() / mTiempoDeVida.asSeconds();
   mVertices[i].color.a = <static_cast>sf::uint8(rango * 255);
  }
 }

private:

 virtual void draw( sf :: RenderTarget &target , sf :: RenderStates states ) const
 {
  //se transforma
  states.transform = getTransform();

  //las particulas no usan textura
  states.texture = nullptr;

  //Dibuja el vertex array
  target.draw( mVertices , states );
 }

private:

 struct  Particula
 {
  sf::Vector2f velocidad;
  sf::Time tiempoDeVida;
 };

 void resetParticula(std::size_t index)
 {
  //Se le da una velocidad aleatoria y el ciclo de vida de la particula
  float angulo = (std::rand() % 360) * 3.14f / 180.f;
  float velocidad = (std::rand() % 50) + 50.f;
  mParticulas[index].velocidad = sf::Vector2f(std::cos(angulo) * velocidad, std::sin(angulo) * velocidad);
  mParticulas[index].tiempoDeVida = sf::milliseconds((std::rand() % 2000) + 1000);

  //Resetea la posicion del correspondiente vertex
  mVertices[index].position = mEmision;
 }


private:

 std::vector<Particula>mParticulas;
 sf::VertexArray mVertices;
 sf::Time mTiempoDeVida;
 sf::Vector2f mEmision;
};

Main.cpp

#include "SistemaParticulas.h"

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(800, 600), "Sistema de Particulas");
 window.setFramerateLimit(60);

 //Creo mi sistema de particulas
 SistemaParticulas particulas(5000);

 //Creo un clock para el tiempo transcurrido
 sf::Clock tiempoTranscurrido;

 //GameLoop
 while (window.isOpen())
 {
  window.clear();

  //Realiza el sistema de particulas siguiendo el mouse
  sf::Vector2i mouse = sf::Mouse::getPosition(window);
  particulas.setEmision( window.mapPixelToCoords(mouse));

  //Actualizamos el tiempo
  sf::Time tiempo = tiempoTranscurrido.restart();
  particulas.update( tiempo );

  //muestro las particulas
  window.draw(particulas);

  //Evento Salir
  sf::Event event;

  while (window.pollEvent(event))
  {
   if (event.type == sf::Event::Closed)
   {
    window.close();
   }
  }

  window.display();
 }

 return 0;
}



Fuentes en SFML


Descargar Assets para este proyecto


#include <SFML\Graphics.hpp>
#include <iostream>

using namespace std;

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(800, 600), "Fuentes SFML");
 window.setFramerateLimit(60);

 //Defino mi fuente
 sf::Font fuente;

 //si marca error al cargar
 if (!fuente.loadFromFile("Sansation.ttf"))
 {
  cout << "Error: " << endl;
 }

 //Si esta todo bien podemos mostrar texto en la pantalla
 sf::Text texto;
  
 //cargamos la fuente
 texto.setFont( fuente );

 //Le asignamos el texto que queremos mostrar
 texto.setString("Hola a todos");

 //Le indicamos el tamaño de la letra
 texto.setCharacterSize( 24 );

 //Le colocamos un color
 texto.setColor( sf :: Color :: Blue );

 //y le indicamos un estilo al texto
 texto.setStyle( sf :: Text :: Bold );
 
 //creo mi gameloop
 while (window.isOpen())
 {
  //limpio la ventana
  window.clear(sf::Color::White);

  //mostramos el texto en la pantalla
  window.draw( texto );

  //mostrar en pantalla
  window.display();

  sf::Event event;

  while (window.pollEvent(event))
  {
   
   //Evento Cerrar
   if (event.type == sf::Event::Closed)
    window.close();
  }
 }

 return 0;
}



lunes, 30 de marzo de 2015

Cerrar Ventana con boton Windows Forms

1.- Crear un proyecto nuevo en Windows Forms Visual C++ y agregar un botón y cambiarle su texto a salir, cerrar u otro sinónimo.



Menus en Windows Forms

1.- Creamos un nuevo proyecto en windows forms y nos vamos en la parte derecha donde están los controles y le damos en menús y barras de herramientas y escogemos MenuStrip y lo jalamos al form.



2.- Nos aparecerá una caja de texto donde se nos indicara en poner un texto.


TabControl en Windows Forms

1.- Creamos un nuevo proyecto en windows forms y nos vamos a la pestaña de contenedores, ahí encontraremos TabControl.


domingo, 29 de marzo de 2015

Cambiar a otro Activity usando Intents en Android Studio



1.- Creamos un nuevo proyecto en android studio, por lo regular se crea el archivo myActivity.java y main.xml. Lo primero que tenemos que hacer es crear un nuevo Activity en la carpeta src y en la carpeta res/layout copiar el main.xml y colocarle un nombre alternativo en mi caso le puse segundomain.xml y para mi activity Activity2.java.




2.- Una vez hecho esto abriremos el archivo AndroidManifest que se encuentra justo después de los activities y lo editamos de la siguiente manera.


AndroidManifest.xml

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="kenny.master.kenny"
          android:versionCode="1"
          android:versionName="1.0">
    <uses-sdk android:minSdkVersion="13"/>
    <application android:label="kenny">
        <activity android:name="MyActivity"
                  android:label="kenny">
            <intent-filter>
                <action android:name="android.intent.action.MAIN"/>
                <category android:name="android.intent.category.LAUNCHER"/>
            </intent-filter>
        </activity>
        <!-- Aqui va ir la definicion de la segunda Activity-->
        <activity
                android:label="Activity2"
                android:name=".Activity2">
            <intent-filter>
                <action android:name="kenny.master.Activity2"/action>
                <category android:name="android.intent.category.DEFAULT"/category>
            </intent-filter>
        </activity>
        <!-- Aqui termina nuestra declaracion-->
    </application>
</manifest>


3.- Ahora tocara editar el archivo segundomain.xml colocando lo siguiente.


segundomain.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="fill_parent"
              android:layout_height="fill_parent"
        >

<TextView
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="Esta es la segunda activity"
        />

</LinearLayout>



4.- Ya hecho esto editamos el archivo Activity2 colocando el siguiente codigo


Activity2.java

package kenny.master.kenny;

import android.app.Activity;
import android.os.Bundle;


public class Activity2 extends Activity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        //Agregamos el archivo xml de la segundomain
        setContentView( R.layout.segundomain );
    }
}

5.-  Toca el turno de editar el archivo main.xml poniendo lo siguiente


main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="fill_parent"
              android:layout_height="fill_parent"
        >

<Button
        android:layout_width="fill_parent"
        android:layout_height="wrap_content"
        android:text="Mostrar la segunda activity"
        android:onClick="onClick"
        />

</LinearLayout>

6.- Ya por ultimo tendremos que editar el archivo MyActivity colocando lo siguiente


MyActivity.java

package kenny.master.kenny;

import android.app.Activity;
import android.os.Bundle;

//librerias a utilizar
import android.content.Intent;
import android.view.View;

public class MyActivity extends Activity {

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

    //Creamos nuestros evento onClick
    public void onClick( View v )
    {
        startActivity( new Intent("kenny.master.Activity2"));
    }
}

7.- Probar el resultado.



Dialogo de progreso 2 en Android Studio


main.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="fill_parent"
              android:layout_height="fill_parent"
        >

    <Button
            android:id="@+id/btn_dialog"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="Clic para mostrar dialogo"
            android:onClick="onClick"
            />

    <Button
            android:id="@+id/btn_dialog2"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="Clic para mostrar la barra de progreso"
            android:onClick="onClick2"
            />

    <Button
           android:id="@+id/btn_dialog3"
           android:layout_width="fill_parent"
           android:layout_height="wrap_content"
           android:text="Clic para mostrar detallamente la barra de progreso"
           android:onClick="onClick3"
           />

</LinearLayout>



MyActivity.java

package kenny.master.kenny;

import android.app.Activity;
import android.os.Bundle;

//librerias a utilizar
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.app.Dialog;
import android.app.ProgressDialog;
import android.content.DialogInterface;
import android.view.View;
import android.widget.Toast;

public class MyActivity extends Activity {

    //Declaro arreglos para mis elementos
    CharSequence[] items = { "One Piece" , "Pokemon" , "Dragon Ball Z" };
    boolean[] itemCheked = new boolean[ items.length ];

    //Declaro mi variable para la barra de progeso
    ProgressDialog progressDialog;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

    //creo mi primer evento onClick
    public void onClick( View v )
    {
        showDialog(0);
    }

    //creo mi segundo evento onClick
    public void onClick2( View v )
    {
        //muestro el dialogo
        final ProgressDialog dialog = ProgressDialog.show( this , "Realiza alguna accion" , "Espera por favor..." , true );

        //Creo un hilo para determinar los tiempos de la barra de progreso
        new Thread(new Runnable() {
            @Override
            public void run() {
                try
                {
                    //Esperamos 5 segundos
                    Thread.sleep( 5000 );
                    dialog.dismiss();
                } catch( InterruptedException e )
                {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    //Creo mi tercer evento onClick
    public void onClick3( View v )
    {
        showDialog(1);
        progressDialog.setProgress(0);

        //Creo mi hilo para el tiempo
        new Thread(new Runnable() {
            @Override
            public void run() {
                for( int i = 1 ; i <= 15 ; i++ )
                {
                    try {
                        Thread.sleep( 1000 );

                        //Actualizo el dialogo
                        progressDialog.incrementProgressBy((int)(100 / 15 ));
                    } catch( InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }

                //cierro la barra de progreso
                progressDialog.dismiss();
            }
        }).start();
    }

    @Override
    protected Dialog onCreateDialog( int id )
    {
      switch ( id )
      {
          case 1:
              progressDialog = new ProgressDialog( this );
              progressDialog.setTitle("Descargando arhivos....");
              progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
              progressDialog.setButton(DialogInterface.BUTTON_POSITIVE, "Descargar",
                      new DialogInterface.OnClickListener() {
                          @Override
                          public void onClick(DialogInterface dialog, int escogerBoton) {
                              Toast.makeText(getBaseContext(), "Descargar presionado", Toast.LENGTH_SHORT).show();
                          }
                      });
           progressDialog.setButton(DialogInterface.BUTTON_NEGATIVE, "Cancelar",
                   new DialogInterface.OnClickListener() {
                       @Override
                       public void onClick(DialogInterface dialogInterface, int escogerBoton) {
                           Toast.makeText(getBaseContext() , "Cancelar presionado" , Toast.LENGTH_SHORT ).show();
                       }
                   });
              return progressDialog;
      }
        return null;
    }
}




Texturas y Sprites en SFML


#include <SFML\Graphics.hpp>
#include <iostream>

using namespace std;

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(800, 600), "Texturas y Sprites SFML");
 window.setFramerateLimit(60);

 //Creo mi textura
 sf::Texture textura;

 //si hubiera algun error al cargar la textura
 if (!textura.loadFromFile("Vampcube.png"))
 {
  cout << "No se pudo cargar la textura" << endl;
 }

 //podemos darle un mejor efecto a nuestra textura al incluir la siguiente linea
 textura.setSmooth( true );

 //Creamos nuestro sprite ahora que hemos definido una textura
 sf::Sprite sprite;
 sprite.setTexture(textura);

 //Establecemos su posicion en la ventana
 sprite.setPosition(250, 150);

 //creo mi gameloop
 while (window.isOpen())
 {
  //limpio la ventana
  window.clear(sf::Color::White);

  //dibujamos el sprite
  window.draw( sprite );

  //mostrar en pantalla
  window.display();

  sf::Event event;

  while (window.pollEvent(event))
  {
   
   //Evento Cerrar
   if (event.type == sf::Event::Closed)
    window.close();
  }
 }

 return 0;
}




Evento JoystickButtonPressed en SFML


#include <SFML\Graphics.hpp>
#include <iostream>

using namespace std;

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(800, 600), "Evento JoystickButtonPressed SFML");
 window.setFramerateLimit(60);

 //creo mi gameloop
 while (window.isOpen())
 {
  //limpio la ventana
  window.clear(sf::Color::White);

  //mostrar en pantalla
  window.display();

  sf::Event event;

  while (window.pollEvent(event))
  {
   //evento  joystick boton presionado
   if (event.type == sf::Event:: JoystickButtonPressed )
   {
    cout << "Boton Joystick presionado" << endl;
    cout << "ID joystick: " << event.joystickButton.joystickId << endl;
    cout << "boton: " << event.joystickButton.button << endl;
   }
   

   //Evento Cerrar
   if (event.type == sf::Event::Closed)
    window.close();
  }
 }

 return 0;
}

Evento JoystickConnected y JoystickDisconnected en SFML


#include <SFML\Graphics.hpp>
#include <iostream>

using namespace std;

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(800, 600), "Evento JoystickConnected SFML");
 window.setFramerateLimit(60);

 //creo mi gameloop
 while (window.isOpen())
 {
  //limpio la ventana
  window.clear(sf::Color::White);

  //mostrar en pantalla
  window.display();

  sf::Event event;

  while (window.pollEvent(event))
  {
   //evento  joystick Conectado y Desconectado
   if (event.type == sf::Event::JoystickConnected)
    cout << "joystick conectado: " << event.joystickConnect.joystickId << std::endl;

   if (event.type == sf::Event::JoystickDisconnected)
    cout << "joystick desconectado: " << event.joystickConnect.joystickId << std::endl;

   //Evento Cerrar
   if (event.type == sf::Event::Closed)
    window.close();
  }
 }

 return 0;
}



Efecto Fade in y Fade out a la pantalla en Irrlicht


#include <irrlicht.h>

//los namespace para definir funciones de irrlicht
using namespace irr;
using namespace core;
using namespace video;

#if defined(_MSC_VER)
#pragma comment(lib, "Irrlicht.lib")
#endif

int main()
{
 //define un device para la pantalla
 IrrlichtDevice *device = createDevice(EDT_OPENGL, dimension2d<u32>(640, 480), 16, false,
  false, false, 0);

 if (!device)
  return 1;

 IVideoDriver *driver = device->getVideoDriver();

 //creo variables para mis colores
 f32 r = 255.0f;
 f32 g = 255.0f;
 f32 b = 255.0f;

 bool fadeOut = true;
 int lastFPS = -1;

 u32 then = device->getTimer()->getTime();
 const f32 fadeRate = 0.1f;

 //Gameloop
 while (device->run())
 {
  //manejo los tiempos
  const u32 now = device->getTimer()->getTime();
  const f32 frameDeltaTime = (f32)(now - then);
  then = now;

  if (r <= 0.0f)
   fadeOut = false;

  else if (r >= 255.0f)
   fadeOut = true;

  //Crea el efecto fadeout y fadein
  if (fadeOut)
  {
   r -= fadeRate * frameDeltaTime;
   g -= fadeRate * frameDeltaTime;
   b -= fadeRate * frameDeltaTime;
  }

  else
  {
   r += fadeRate * frameDeltaTime;
   g += fadeRate * frameDeltaTime;
   b += fadeRate * frameDeltaTime;
  }



  driver->beginScene(true, true, SColor(255, (u32)r, (u32)g, (u32)b));
  driver->endScene();
 }

 //cerrar device
 device->drop();

 return 0;
}

sábado, 28 de marzo de 2015

Simulacion de fisica con cubos en Box2D


Descargar Assets para este proyecto


#include <SFML\Graphics.hpp>
#include <Box2D\Box2D.h>

//Es necesario para convertir de pixeles a coordenadas del mundo real
static const float ESCALA = 30.f;

//Creo funciones para crear las cajas y el suelo
void CrearCaja(b2World &world, float mouseX, float mouseY );
void CrearSuelo(b2World &world, float posX , float posY );

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(800, 600, 32), "Generar Cubos con el Mouse");
 window.setFramerateLimit(60);

 //Preparo el World para Box2D
 b2Vec2 gravity( 0.f , 9.8f);
 b2World world( gravity );

 //mando a llamar a mi funcion para crear el suelo
 CrearSuelo( world , 400.f , 500.f );

 //Preparo mi texturas
 sf::Texture texturaCaja;
 sf::Texture texturaSuelo;

 texturaCaja.loadFromFile("box1.png");
 texturaSuelo.loadFromFile("ground.png");

 //inicio mi gameloop
 while (window.isOpen())
 {
  //le indico que generara las cajas con el boton izquierdo del mouse
  if (sf::Mouse::isButtonPressed( sf :: Mouse :: Left ) )
  {
   //obtengo las posiciones donde se hizo clic
   int mouseX = sf::Mouse::getPosition(window).x;
   int mouseY = sf::Mouse::getPosition(window).y;
  //y genero las cajas pasando la posiciones donde se dio clic
   CrearCaja( world , mouseX , mouseY );
  }

  //con esto inicio la simulacion de fisica de box2d
  world.Step( 1 / 60.f , 8 , 3 );

  //Limpio la pantalla a un color blanco
  window.clear(sf::Color::White);

  //Realizo un contador de bodies
  int contador = 0;

  //Realizo un bodyiterator para crear un ciclo de bodies creados
  for (b2Body *bodyIterator = world.GetBodyList(); bodyIterator != 0; bodyIterator = bodyIterator->GetNext())
  {
   if (bodyIterator->GetType() == b2_dynamicBody)
   {
    sf::Sprite sprite;
    sprite.setTexture( texturaCaja );
    sprite.setOrigin( 16.f , 16.f );
    sprite.setPosition(ESCALA * bodyIterator->GetPosition().x, ESCALA * bodyIterator->GetPosition().y);
    sprite.setRotation( bodyIterator -> GetAngle() * 180 / b2_pi );
    window.draw( sprite );
    ++contador;
   }

   else
   {
    sf::Sprite suelo;
    suelo.setTexture( texturaSuelo );
    suelo.setOrigin(400.f, 8.f);
    suelo.setPosition(bodyIterator->GetPosition().x * ESCALA, bodyIterator->GetPosition().y * ESCALA);
    suelo.setRotation(180 / b2_pi * bodyIterator->GetAngle());
    window.draw( suelo );
   }
  }

  window.display();

  //Creo un evento de salida
  sf::Event event;

  while (window.pollEvent(event))
  {
   if (event.type == sf::Event::Closed)
    window.close();
  }
 }

 return 0;
}

void CrearCaja(b2World &world, float mouseX, float mouseY)
{
 //defino mi body
 b2BodyDef bodyDef;
 bodyDef.position = b2Vec2( mouseX / ESCALA , mouseY / ESCALA );
 bodyDef.type = b2_dynamicBody;
 b2Body *body = world.CreateBody(&bodyDef);

 //Creo la forma de la caja
 b2PolygonShape caja;
 caja.SetAsBox( (128.f / 2 ) / ESCALA , ( 128.f / 2 ) / ESCALA );

 //Creo mi fixture
 b2FixtureDef fixtureDef;
 fixtureDef.density = 1.f;
 fixtureDef.friction = 0.7f;
 fixtureDef.shape = &caja;

 body->CreateFixture( &fixtureDef );
}

void CrearSuelo(b2World &world, float posX, float posY)
{
 //defino mi bodyDef
 b2BodyDef bodyDef;
 bodyDef.position = b2Vec2( posX / ESCALA , posY / ESCALA );
 bodyDef.type = b2_staticBody;
 b2Body *body = world.CreateBody( &bodyDef );

 //Creo su forma
 b2PolygonShape suelo;
 suelo.SetAsBox((800.f / 2) / ESCALA , ( 16.f / 2 ) / ESCALA );

 //Creo su fixture
 b2FixtureDef fixtureDef;
 fixtureDef.density = 0.f;
 fixtureDef.shape = &suelo;
 body->CreateFixture( &fixtureDef );
}



Evento MouseButtonPressed en SFML


#include <SFML\Graphics.hpp>
#include <iostream>

using namespace std;

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(800, 600), "Evento MouseButtonPressed SFML");
 window.setFramerateLimit(60);

 //creo mi gameloop
 while (window.isOpen())
 {
  //limpio la ventana
  window.clear(sf::Color::White);

  //mostrar en pantalla
  window.display();

  sf::Event event;

  while (window.pollEvent(event))
  {
   //evento presionar boton del mouse
   if (event.type == sf::Event:: MouseButtonPressed )
   {
    if (event.mouseButton.button == sf::Mouse::Left)
    {
     cout << "Boton izquierdo presionado" << endl;
     cout << "posicion x: " << event.mouseButton.x << " - posicion y: " << event.mouseButton.y << endl;
    }
   }
   

   //Evento Cerrar
   if (event.type == sf::Event::Closed)
    window.close();
  }
 }

 return 0;
}

Evento MouseWheelMoved en SFML


#include <SFML\Graphics.hpp>
#include <iostream>

using namespace std;

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(800, 600), "Evento MouseWheelMoved SFML");
 window.setFramerateLimit(60);

 //creo mi gameloop
 while (window.isOpen())
 {
  //limpio la ventana
  window.clear(sf::Color::White);

  //mostrar en pantalla
  window.display();

  sf::Event event;

  while (window.pollEvent(event))
  {
   //evento mover la ruedita del mouse
   if (event.type == sf::Event:: MouseWheelMoved )
   {
    cout << "Mover raton: " << event.mouseWheel.delta << endl;
    cout << "posicion x: " << event.mouseWheel.x << " - posicion y: " << event.mouseWheel.y << endl;
   }
   

   //Evento Cerrar
   if (event.type == sf::Event::Closed)
    window.close();
  }
 }

 return 0;
}

Evento MouseMoved en SFML


#include <SFML\Graphics.hpp>
#include <iostream>

using namespace std;

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(800, 600), "Evento MouseMoved SFML");
 window.setFramerateLimit(60);

 //creo mi gameloop
 while (window.isOpen())
 {
  //limpio la ventana
  window.clear(sf::Color::White);

  //mostrar en pantalla
  window.display();

  sf::Event event;

  while (window.pollEvent(event))
  {
   //evento  movimiento del raton
   if (event.type == sf::Event:: MouseMoved)
   {
    cout << "posicion x: " << event.mouseMove.x << " - posicion y: " << event.mouseMove.y << endl;
   }
   

   //Evento Cerrar
   if (event.type == sf::Event::Closed)
    window.close();
  }
 }

 return 0;
}

Evento KeyPressed en SFML


#include <SFML\Graphics.hpp>
#include <iostream>

using namespace std;

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(800, 600), "Evento Keypressed SFML");
 window.setFramerateLimit(60);

 //creo mi gameloop
 while (window.isOpen())
 {
  //limpio la ventana
  window.clear(sf::Color::White);

  //mostrar en pantalla
  window.display();

  sf::Event event;

  while (window.pollEvent(event))
  {
   //evento presionar con el teclado
   if (event.type == sf::Event::KeyPressed)
   {
    if (event.key.code == sf::Keyboard::A)
    {
     cout << "Has presionado la tecla A" << endl;
    }
   }
   

   //Evento Cerrar
   if (event.type == sf::Event::Closed)
    window.close();
  }
 }

 return 0;
}

Evento Closed en SFML


#include <SFML\Graphics.hpp>

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(800, 600), "Evento Cerrar SFML");
 window.setFramerateLimit(60);

 //creo mi gameloop
 while (window.isOpen())
 {
  //limpio la ventana
  window.clear(sf::Color::White);

  //mostrar en pantalla
  window.display();

  sf::Event event;

  while (window.pollEvent(event))
  {
   //Evento Cerrar
   if (event.type == sf::Event::Closed)
    window.close();
  }
 }

 return 0;
}

Creación de pantalla Irrlicht


#include <irrlicht.h>

//los namespace para definir funciones de irrlicht
using namespace irr;
using namespace core;
using namespace video;

#if defined(_MSC_VER)
#pragma comment(lib, "Irrlicht.lib")
#endif

int main()
{
 //define un device para la pantalla
 IrrlichtDevice *device = createDevice(EDT_OPENGL, dimension2d<u32>(640, 480), 16, false,
  false, false, 0);

 if (!device)
  return 1;

 IVideoDriver *driver = device->getVideoDriver();

 //Gameloop
 while (device->run())
 {
  driver->beginScene( true , true , SColor( 255 , 255 , 255 , 255 ) );
  driver->endScene();
 }

 //cerrar device
 device->drop();

 return 0;
}



Primer programa en Irrlicht


#include <irrlicht.h>

//los namespace para definir funciones de irrlicht
using namespace irr;
using namespace core;
using namespace video;

//estaba definiendo mal y marco error de unresolve internal tener en cuenta
#if defined(_MSC_VER)
#pragma comment(lib, "Irrlicht.lib")
#endif

int main()
{
 //define un device para la pantalla
 IrrlichtDevice *device = createDevice(EDT_OPENGL, dimension2d<u32>(640, 480), 16, false,
  false, false, 0);

 if (!device)
  return 1;

 //cerrar device
 device->drop();

 system("pause");

 return 0;
}



viernes, 27 de marzo de 2015

Dialogo de Proceso en Android Studio


main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:orientation="vertical"
              android:layout_width="fill_parent"
              android:layout_height="fill_parent"
        >

   <Button
            android:id="@+id/btn_dialog"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="Clic para mostrar dialogo"
            android:onClick="onClick" />
            

    <Button
            android:id="@+id/btn_dialog2"
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="Clic para mostrar la barra de progreso"
            android:onClick="onClick2" />

            
</LinearLayout>

MyActivity.java

package kenny.master.BarraProceso;

import android.app.Activity;
import android.os.Bundle;

//librerias a utilizar
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.app.Dialog;
import android.app.ProgressDialog;
import android.content.DialogInterface;
import android.view.View;
import android.widget.Toast;

public class MyActivity extends Activity {

    //Declaro arreglos para mis elementos
    CharSequence[] items = { "One Piece" , "Pokemon" , "Dragon Ball Z" };
    boolean[] itemCheked = new boolean[ items.length ];

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

    //creo mi primer evento onClick
    public void onClick( View v )
    {
        showDialog(0);
    }

    //creo mi segundo evento onClick
    public void onClick2( View v )
    {
        //muestro el dialogo
        final ProgressDialog dialog = ProgressDialog.show( this , "Realiza alguna accion" , "Espera por favor..." , true );

        //Creo un hilo para determinar los tiempos de la barra de progreso
        new Thread(new Runnable() {
            @Override
            public void run() {
                try
                {
                    //Esperamos 5 segundos
                    Thread.sleep( 5000 );
                    dialog.dismiss();
                } catch( InterruptedException e )
                {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}





GroupBox en Windows Forms

1.- Primero iniciamos un proyecto nuevo en Windows Forms, y nos vamos al panel de controles en la parte de contenedores, ahí se encontrara GroupBox.



2.- Básicamente groupbox nos sirve para acomodar otros controles pero de manera mas visual, ordenada para dar un mejor apreciación de un formulario, cuando añadamos este control veremos que sera un poco incomodo de momento acomodarlo, en la parte superior izquierda se encuentra un botón en forma de cruz el cual nos servirá para moverlo mejor, en la parte de propiedades podemos personalizar el nombre de este panel.



3.- Para terminar pondremos los groupbox que deseemos y añadir controles ya vistos como lo son etiquetas, texbox y checkbox para poder crear un prototipo de formulario.



Hilos SFML


#include <SFML\Graphics.hpp>
#include <iostream>

using namespace std;


void funcion()
{
 for (int i = 0; i < 10; ++i)
 {
  cout << "Primer Hilo" << endl;
 }
}

int main()
{
 //Crea el hilo pasandole la referencia de la funcion
 sf::Thread thread(&funcion);

 //empieza a correr el hilo
 thread.launch();

 //el primer hilo sigue corriendo
 for (int i = 0; i < 10; ++i)
 {
  cout << "Hilo del main" << endl;
 }

 system("pause");
 return 0;
}




miércoles, 25 de marzo de 2015

Dibujar Rectangulo y Circulo en SFML


#include <SFML\Graphics.hpp>

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(800, 600), "Figuras SFML");
 window.setFramerateLimit(60);

 //creo el circulo en SFML
 sf::CircleShape circulo(100.f);
 circulo.setFillColor(sf::Color::Red);

 //creo el rectangulo en SFML
 sf::RectangleShape rectangulo(sf::Vector2f(200.f, 80.f));
 rectangulo.setFillColor(sf::Color::Cyan);

 //creo mi gameloop
 while (window.isOpen())
 {
  //limpio la ventana
  window.clear(sf::Color::White);

  //Establesco las posiciones de mis figuras
  circulo.setPosition( 100 , 100 );
  rectangulo.setPosition( 400 , 400 );

  //las dibujo en la escena
  window.draw(circulo);
  window.draw(rectangulo);

  //mostrar en pantalla
  window.display();

  sf::Event event;

  while (window.pollEvent(event))
  {
   if (event.type == sf::Event::Closed)
    window.close();
  }
 }

 return 0;
}


Practica siempre para ir mejorando, la repetición y la constancia nos ayudan a mejorar, recuerda cada vez lo harás mejor, si te equivocas esta bien, permitirse equivocarse es la clave de mejora continua, así que permítete equivocarte mas seguido.

Si te gusta este sitio y deseas que esto continué vivo tu apoyo sera importante, puedes dar clic en la publicidad si lo deseas o puedes donar algo en Patreon si puedes permitírtelo, con esto el proyecto empezara a tener un objetivo y dejara de navegar sin rumbo y empezara a convertirse en una comunidad que ayudara unos a los otros, saludos y excelente día.

Polygon Shape en Box2D


#include <SFML\Graphics.hpp>
#include <Box2D\Box2D.h>

#define RAD 0.0174532925199432957f

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(800, 600), "Polygon Shape");
 window.setFramerateLimit( 60 );
 
 //para empezar la simulacion del mundo con esto simula la fisica
 float32 timeStep = 1.0f / 60.f;
 int32 velocityIterations = 8;
 int32 positionIterations = 3;

 //defino mi vector de gravedad
 b2Vec2 gravity( 0.f , 10.f );

 //creo mi mundo
 b2World world( gravity );

 //definimos un bodydef para dynamicbody
 b2BodyDef bodyDefDynamic;
 bodyDefDynamic.type = b2_dynamicBody;
 bodyDefDynamic.position.Set(150.f, 50.f);

 //definimos un bodydef para dynamicbody
 b2BodyDef bodyDefDynamic1;
 bodyDefDynamic1.type = b2_dynamicBody;
 bodyDefDynamic1.position.Set(150.f, 400.f);

 //creamos los body
 b2Body *dynamicBody = world.CreateBody(&bodyDefDynamic);
 b2Body *dynamicBody1 = world.CreateBody(&bodyDefDynamic1);

 //se crea un circleshape
 b2CircleShape circle;
 circle.m_p.Set(0, 0);
 circle.m_radius = 1;

 //Se crea el polygonshape
 b2PolygonShape rect;
 rect.SetAsBox(2, 1);

 //Creamos un fixture para darle mas dinamismo
 b2FixtureDef fixtureDefDynamic;
 fixtureDefDynamic.shape = &circle;

 //Creamos un fixture para darle mas dinamismo
 b2FixtureDef fixtureDefDynamic1;
 fixtureDefDynamic1.shape = &rect;

 //Creamos la fixture
 dynamicBody->CreateFixture(&fixtureDefDynamic);
 dynamicBody1->CreateFixture(&fixtureDefDynamic1);

 //creo el circulo en SFML
 sf::CircleShape circulo(100.f);
 circulo.setFillColor(sf::Color::Red);

 //creo el rectangulo en SFML
 sf::RectangleShape rectangulo( sf :: Vector2f( 200.f , 80.f ) );
 rectangulo.setFillColor(sf::Color::Cyan);
 
 //creo mi gameloop
 while (window.isOpen())
 { 

  //lo inicio en el gameloop.
  world.Step(timeStep, velocityIterations, positionIterations);

  //limpio la ventana
  window.clear(sf::Color::White);

  circulo.setPosition(dynamicBody->GetPosition().x, dynamicBody->GetPosition().y);
  rectangulo.setPosition(dynamicBody1->GetPosition().x, dynamicBody1->GetPosition().y);

  window.draw(circulo);
  window.draw( rectangulo );

  //mostrar en pantalla
  window.display();

  sf::Event event;

  while (window.pollEvent(event))
  {
   if (event.type == sf::Event::Closed)
    window.close();
  }
 }

 return 0;
}

Circle Shape en Box2D


#include <SFML\Graphics.hpp>
#include <Box2D\Box2D.h>

#define RAD 0.0174532925199432957f

int main()
{
 //Creo mi ventana
 sf::RenderWindow window(sf::VideoMode(800, 600), "Circle Shape");
 window.setFramerateLimit( 60 );
 
 //para empezar la simulacion del mundo con esto simula la fisica
 float32 timeStep = 1.0f / 60.f;
 int32 velocityIterations = 8;
 int32 positionIterations = 3;

 //defino mi vector de gravedad
 b2Vec2 gravity( 0.f , 10.f );

 //creo mi mundo
 b2World world( gravity );

 //definimos un bodydef para dynamicbody
 b2BodyDef bodyDefDynamic;
 bodyDefDynamic.type = b2_dynamicBody;
 bodyDefDynamic.position.Set(150.f, 50.f);

 //creamos los body
 b2Body *dynamicBody = world.CreateBody(&bodyDefDynamic);

 //se crea un circleshape
 b2CircleShape circle;
 circle.m_p.Set(0, 0);
 circle.m_radius = 1;

 //Creamos un fixture para darle mas dinamismo
 b2FixtureDef fixtureDefDynamic;
 fixtureDefDynamic.shape = &circle;

 //Creamos la fixture
 dynamicBody->CreateFixture(&fixtureDefDynamic);

 sf::CircleShape circulo(100.f);
 circulo.setFillColor(sf::Color::Red);
 
 //creo mi gameloop
 while (window.isOpen())
 { 

  //lo inicio en el gameloop.
  world.Step(timeStep, velocityIterations, positionIterations);

  //limpio la ventana
  window.clear(sf::Color::White);

  circulo.setPosition(dynamicBody->GetPosition().x, dynamicBody->GetPosition().y);

  window.draw(circulo);
  //mostrar en pantalla
  window.display();

  sf::Event event;

  while (window.pollEvent(event))
  {
   if (event.type == sf::Event::Closed)
    window.close();
  }
 }

 return 0;
}