Pálya és ütő elkészítése

Helló!

Nos, mostmár ideje elkezdeni a játék megvalósítását, elsőként rajzoljuk meg a pályát és csináljuk meg az ütőt ami az egérrel mozgatható(erről fog szólni ez a post).

Hát akkor vágjunk is bele, hozzunk létre egy új üres Javascript projektet a szokásos módon és hozzunk létre egy 800×600-as canvast(ekkora lesz a pályánk) ill. néhány segédváltozót.

html(default.html):

<body>
    <canvas class="court" id="court" style="background-color:darkcyan"></canvas>
</body>

javascript(default.js):

window.onload = initialize;
function initialize() {
    var x, y;  //segedvaltozok az eger x, y koordinatainak lekeresehez
    var racket = {x:350,y:250, widht:100, height:60}; // az uto
    var court = document.getElementById("court");
    var ctx = court.getContext("2d");
    court.width = 800;
    court.height = 600;
}

Igazítsuk középre a pályánkat(default.css):

.court {
    width:800px;
    height:600px;
    position:absolute;
    left:50%;
    top:50%;
    margin:-300px 0 0 -400px;
}

Ezután rajzoljuk meg a pályánkat az initialize() függvényen belül ami a következőképp fog kinézni:

function Draw() {
    ctx.clearRect(0, 0, court.width, court.height);
    ctx.beginPath();
    ctx.rect(2, 2, 796, 596);
    ctx.rect(100, 100, 600, 400);
    ctx.rect(200, 200, 400, 200);
    ctx.moveTo(0, 0);
    ctx.lineTo(200, 200);
    ctx.moveTo(800, 0);
    ctx.lineTo(600, 200);
    ctx.moveTo(800, 600);
    ctx.lineTo(600, 400);
    ctx.moveTo(0, 600);
    ctx.lineTo(200, 400);
    ctx.strokeStyle = 'lightgrey';
    ctx.lineWidth = 4;
    ctx.stroke();

    //uto kirajzolasa
    ctx.beginPath();
    ctx.rect(racket.x, racket.y, racket.widht, racket.height);
    ctx.strokeStyle = 'grey';
    ctx.lineWidth = 3;
    ctx.stroke();

    //ez lesz a labdank(a kovetkezo post-ban targyaljuk a mozgasat)
    ctx.beginPath();
    ctx.arc(400, 300, 15, 0, 2 * Math.PI, false);
    ctx.strokeStyle = "white";
    ctx.lineWidth = 1;
    ctx.stroke();
}

Az ütő mozgásához további két függvényt kell megvalósítanunk eggyikkel az egér x, y koordinátáit kérhetjük le a mássikkal pedig beállítjuk az ütő koordinátáit az egér koordinátáira, lássuk hogyan is fog ez kinézni:

// az eger koordinatainak lekerese
function getMousePos(canvas, evt) {
    var rect = court.getBoundingClientRect();
    return {
    x: evt.clientX - rect.left,
    y: evt.clientY - rect.top
    };
}

//uto koordinatainak beallitasa
court.addEventListener('mousemove', function (evt) {
    var mousePos = getMousePos(court, evt);
    racket.x = mousePos.x-50;
    racket.y = mousePos.y-30;
}, false);

Ha mindennel megvagyunk már csak egy lépés van hátra, mégpedig a canvas ujrarajzolása, amit a setInterval(…) függvénnyel tehetünk meg. Adjuk hozzá az initialize() függvényhez a következő sort:

setInterval(function () { Draw() }, 30);

Ha kész vagyunk futtasuk a projektünket és próbáljuk ki.

A teljes projekt innen letölthető: PalyaDemo

Üdv.:
Balázs

Javascript és az osztályok

Helló!

Javascript-ben háromféleképpen hozhatunk létre osztályokat, ezeket foglyuk most végignézni. Fontos azonban megjegyezni, hogy osztályok nincsenek javascriptben, függvényekkel tudjuk szimulálni azokat.

1. Függvényt használva

Létrehozunk egy egyszerű függvényt majd létrehozunk belőle egy objektumot a new kulcsszóval. Példa:

 function Teglalap(a,b){
     this.a = a;
     this.b = b;
     this.kerulet = getKerulet;
}

//a getKerulet lehet a Teglalap fuggvenyen belul is
function getKerulet(){
     return (a + b)*2;
}

Példányosítás(és kiírás konsolra):

var t = new Teglalap(2,3);
consol.log(t.kerulet);

2. Osztályok definiálása Objektumváltózókkal

Ez egy gyorsabb megoldás, kihagyhatjuk az objektum példányosítását és egyből definiáljuk azt:

var teglalap{
   a: 0,
   b: 0,
   kerulet: (a+b)*2
}

teglalap.a = 2;
teglalap.b = 2;

conslo.log(teglalap.kerulet);

3. A kettő keveréke

A Harmadik módszer gyakorlatilag a fenti kettő kombinációja:

var teglalap = new function(){
    this.a = 2;
    this.b = 3;
    this.kerulet = function getKerulet(){ // a getKerulet lehet a fuggvenyen kivul is
        return (a + b)*2; }
}

//valtozok elerese
teglalap.a = 5;
consol.log(teglelep.kerulet);

Röviden ennyit a Js osztályokról.

Üdv.:
Balázs

Mozgás (Javascript)

Helló!

Lássuk hogyan is tudunk mozgásra bírni dolgokat a képernyőn html5-öt és js-et használva.

Hozzunk létre egy új Javascript blank app projektet és nyissuk meg a default.html fájlt, majd hozzunk létre benne két gombot “Move” (ennek hatására elindul az animációnk) és “Stop” (ez pedig megállítja) névvel és hozzuk létre a canvasunkat is.

<button onclick="m.m1()">Move</button>
<button onclick="m.m2()">Stop</button>
<canvas id="canvas"></canvas>

(az onclickről később)

Ha ezzel megvagyunk jöhet is a default.js. Nyissuk meg a fájlt majd hozzunk létre néhány szükséges változót

var canvas, context;    // canvas inicializalasahoz kell
var a = 250;    // a kor kozeppontjanak y koordinataja
var b = 1;      // jobbra vagy balra mozogjon a kor
var x = false;  // van mozgas vagy nincs

Ezután hozzuk létre az “initialize()” függvényünket amiben létrehozzuk a canvas-t és az animációkat amit a következő képpen tudunk megtenni:

window.onload = initialize;
function initialize() {
canvas = document.getElementById("canvas");
canvas.width = window.innerWidth;    //canvas szelessege kepernyo szeles
canvas.height = window.innerHeight;  //canvas szelessege kepernyo magas
context = canvas.getContext("2d");

//ketfele keppen hozhatunk letre animaciot
requestAnimationFrame(move);  // canvas ujrarajzolasa 1
setInterval(function () { redraw()}, 6); // canvas ujrarajzolasa 2
}

Akkor most irjuk meg a move() es a redraw() fuggvenyeket, hogy működjön is.

function redraw() {
context.beginPath();
context.fillStyle = "blue";
if (a > 500)     //ha a kor y koordinátája nagyobb mint 500 akkor irányváltás 
b *= -1;
if (a < 250)     //ha a kor y koordinátája kisebb mint 250 akkor irányváltás
b *= -1;
context.arc(a, 350, 20, 0, Math.PI * 2, true);  // kezdo kor kirajzolasa
//ha rákattintunk a Move gombra x=true
if(x)
//mozgatás jobbra balra y koord. szerint 250 és 500 kozott
context.arc(a += b, 350, 20, 0, Math.PI * 2, true);
context.fill();
}

Most nézzük a move() függvényt(kis különbséggel ugyan az mint az előbb):

function move() {
canvas.width = canvas.width; // képernyő törlése

context.beginPath();
context.fillStyle = "blue";
if (a > 500)
b *= -1;
if (a < 250)
b *= -1;
context.arc(a, 250, 20, 0, Math.PI * 2, true);  // kezdo kor kirajzolasa
if (x)
context.arc(a += b, 250, 20, 0, Math.PI * 2, true);  // mozgatas
context.fill();

requestAnimationFrame(move);
}

Már csak a gombok kezelése van hátra. Elöszőr is írjuk meg a két (on(), off()) fügvényünket ami nem lesz túl bonyolult mindössze az “x” változót állítja “true”-ra  vagy “false”-ra

function on() {
x = true;

function off() {
x = false;
}

Ha ez is megvan már csak egy aprócska lépés van hátra mégpedig, hogy létrehozzunk egy névteret amin keresztül elérjük ezeket a függvényeket a html fájlunkból:

WinJS.Namespace.define("m", { m1: on, m2:off}); // namespace a gombokhoz

Ezután az ‘az oncllick’-nek már átadható m1() ill. m2() függvény ahogy ezt az elején csináltuk.

A gombok középre helyezéséhez a  default.css-be írjuk be a következőket:

body {
text-align:center;
background-color:coral;
}

Ha mindennel megvagyunk futtasuk a projektet és próbáljuk ki.
A forrás innen letölthető: CanvasDemo2

Üdv: Balázs

Rajzolás

Sziasztok!

Most megnézzük hogyan is lehet rajzolni a canvasra html5-ben javascript segítségével.

Először is hozzunk létre egy új projektet a szokásos módon majd nyissuk meg a default.html  fájlt és adjuk hozzá a következő sort a body-hoz:

<canvas id=”canvas”></canvas>

Ha ezzel megvagyunk a default.js fájlra lesz szükségünk amihez adjuk hozzá az initialize() függvényt az „app.oncheckpoint = function (args) {“ sor elé:

function initialize(){

}

A függvényben akkor inicializáljuk is a canvasunkat:

canvas = document.getElementById(“canvas”);
canvas.width = window.innerWidth;
canvas.height = window.innerHeight;
context = canvas.getContext(“2d”);

Ezzel letre is hoztunk egy képernyő mértű rajzterületet amire rajzolhatunk különböző dolgokat pl: vonalat téglalalpot…

Néhány példa:

Vonal rajzlása:

context.strokeStyle = ‘#0f0’; // a vonal színe
context.moveTo(20, 20); //innen indul a vonal rajzolása
context.lineTo(100, 30); //ide húzzuk a vonalat
context.lineWidth = 3; //vonalvastagság
context.stroke(); //végül a rajzolás

kitöltött téglalap rajzolása:

context.fillStyle = ‘#00f’;
context.fillRect(600, 50, 100, 200);
context.lineWidth = 5;
context.stroke();

görbe rajzolása:

//gorbe rajzolasa

context.moveTo(20, 50);
context.quadraticCurveTo(190, 700, 400, 50);
context.lineWidth = 1;
context.stroke();

Végül ahhoz, hogy múködjön is a még egy dologra less szükségünk mégpedig meg kell hívnunk az inicialize() függvényt ezt pedig a következőképp tehetjük meg:

document.addEventListener(“DOMContentLoaded”, initialize, false);

ezt a sort kell betennünk mondjuk az “app.start();” sor elé.

Ha meindennel megvagyunk futtasuk a programunkat és ha minden jól megy akkor a következőnek kell megjelennie elöttünk:

a forrásfájl letölthető innen: CanvasDemo1

Üdv.: Balázs

Kezdeti lépések

Helló,

Egy kis emlékeztető: Célok

Tehát, ahhoz hogy wondow 8 alatt fejlesszünk ’windows store app’ stílusú alkalmazásokat a következő dolgokra lesz szükségünk:

Windows 8

Visual studio 2012 for win8.

Ha ezek telepítésével megvagyunk kezdőthet is a fejlesztés :).

Nyissuk meg a vs2012-őt és hozzunk létre egy új projektet(FILE->new->project), ezután a  templates-ek küzül válasszuk a JavaScript-et itt pedig a Blank App, állítsuk be a projekt helyét és nevezzük el majd ok. Ha minden jól megy létre is jött a projektünk.

A projekt solution-ében a főbb dolgok a következők:

References (windows library for JavaScript)

css mappa: kezdetben a defaultl.css-t tartalmazza, ide menthetjük a különböző css fájljainkat.

images mappa:  kezdetben itt a programunkban talalható kepek vannak például az alkalmazás indulásánál mi jelenjen meg stb. Ezek a fájlok felül írásával könnyedén cseréljetjük ezeket(érdemes odafigyelni hogy azonos felbontású és méretű képekkel írjuk felól a meglévőket)

js mappa: kezdetben a default.js-t tartalmazza ez fogja indítani az alkalmazásunkat

default.html: (fentebb láthtjuk a tartalmát),A WinJS references részt érdemes minden html oldlunkba bemásolni a References részeit „incloudolja”, itt állíthatjuk monjuk az alkalmazásunk stílusát sötétre vagy világosra az „ui-dark.css”, vagy „ui-light.css” segítségével. Ez után saját referenciáinkat is hozzáadjuk jelen esetben a default.css-t és default.js-t.

Ha mindennel megvagyunk futtasuk a programot, ha még nincs tabletünk (ami jelenleg elég valószínű) akkor két lehetőségünk van a futtatásra, futtathatjuk a saját gépünkön(local machine) vagy szimulátoron (Simulator).

Ha elindítottuk az alkalmazásunkat a következő fog megjelenni: „Content goes here”, ez van a html fájlunk body-jában.

Nos egyenlőre ennyi hamarosan folyt. köv.

Üdv.: Balázs

Hangok hozzáadása

Kétféle hang van, folytonos háttérzene és effekt hang.

1. Hozzuk létre a megfelelő változókat
SoundEffect effect;
Song music;

2. A Content projekten belül helyezzük el a hangfájlokat. Célszerű egy új mappát létrehozni.

3. A LoadContent() metóduson belül töltsük be a hangokat
music = Content.Load<Song>( “Sound/gameMusic” );
effect = Content.Load<SoundEffect>( “Sound/laserFire” );

4. A háttérzenét még a LoadContent-ben elindítjuk
PlayMusic( music );

5. Ehhez a PlayMusic metódust létre kell hozni
private void PlayMusic(Song song) {
try {
MediaPlayer.Play( song );
MediaPlayer.IsRepeating = true;
} catch {
}
}

6. Az effekt hangot a megfelelő helyeken elindítjuk
effect.Play();

Szövegek megjelenítése

Sokszor szükséges, hogy a játék aktuális állását megjelenítsük.

1.  Hozzuk létre a következő adattagokat:
int score;
SpriteFont font;

2. Az Initialize() metóduson belül adunk egy kezdőértéket a score változónak

3. A Content projekten belül el kell helyeznünk a betűtípust leíró fájlt. Célszerű egy külön mappába tenni.

4. A LoadContent() metóduson belül betöltjük a betűtípust
font = Content.Load<SpriteFont>( “Fonts/gameFont” );

5. A score változóban tároljuk az aktuális pontszámot. Helyezzük el a megfelelő feltételek után a változó értékét módosító műveleteket.

6. A Draw() metóduson belül kirajzoljuk a szöveget a képernyőre
spriteBatch.DrawString( font, “score: ” + score, new Vector2( GraphicsDevice.Viewport.TitleSafeArea.X, GraphicsDevice.Viewport.TitleSafeArea.Y ), Color.White );

Játékos létrehozása

1. Hozzunk létre egy új XNA projektet, a típusa Windows Phone Game (4.0). Ilyenkor létrejön már a projektben egy Game1.cs nevű főosztály, ennek adhatunk valami beszédesebb nevet.

2. Hozzunk létre egy új osztályt, ez lesz a játékos.

3. Hozzáadjuk a játékos osztályhoz a szükséges adattagokat, és az ezek eléréséhez szükséges metódusokat.

4. A főosztályban létrehozzuk privát adattagként a játékos(oka)t.

5. Az Initialize() metóduson belül példányosítunk.

6. A LoadContent() metódus csak egyszer hívódik meg, itt helyezzük el a textúrák betöltéséhez szükséges utasításokat.

7. A Draw() metódusban hívjuk meg a kirajzoláshoz szükséges metódusokat.

8. A képernyő felbontását a főosztály konstruktorában állítjuk be.

9. Az Update() metódus magát a játékciklust reprezentálja.

Push Notification Service

Hello!

Ma egy Push Notification szerviz készítést mutatok be:

  • Hozzunk létre egy új Azure projektet, adjuk hozzá a WCF Service Web Role-t
  • Töröljük a létrehozott service-t majd adjunk hozzá egy új Silverlight-enabled WCF Service-t
  • Töröljük az alapból létrehozott metódust, majd hozzunk létre egy konstruktor és egy metódust amely elmenti a beregisztrált eszköz címét.Erre a címre küldünk egy tailMessage-t és egy toastMessage-t.
  • Az üzenetek létrehozásához töltsük le ezt majd importáljuk a programba a WindowsPhone.Recipes.Push.Messages.dll-t
  • Adjunk hozzá egy Wp7-es projektet majd ehhez adjuk meg Service Reference-ként a szervizünk címét
  • Egyszerű felületet hozzunk létre kell egy feliratkozás gomb meg egy leiratkozás gomb írjuk meg az click eseménykezelőjét (hozzuk létre a csatornát,kérjük el az üzenetket)

Forrás

Üdv:
Szmeti