← Back to branch summary

~loic.molinari/+junk/qtdeclarative-shadereffectsource-changes

« back to all changes in this revision

Viewing changes to examples/tutorials/samegame/samegame3/samegame.js

  • Committer: Loïc Molinari
  • Date: 2012-04-21 17:59:51 UTC
  • Revision ID: loic.molinari@canonical.com-20120421175951-bqx68caaf5zrp76l
Initial import

Show diffs side-by-side

added added

removed removed

Lines of Context:
examples/tutorials/samegame/samegame3/samegame.js
 
1
/* This script file handles the game logic */
 
2
var maxColumn = 10;
 
3
var maxRow = 15;
 
4
var maxIndex = maxColumn * maxRow;
 
5
var board = new Array(maxIndex);
 
6
var component;
 
7
 
 
8
//Index function used instead of a 2D array
 
9
function index(column, row) {
 
10
    return column + (row * maxColumn);
 
11
}
 
12
 
 
13
function startNewGame() {
 
14
    //Calculate board size
 
15
    maxColumn = Math.floor(gameCanvas.width / gameCanvas.blockSize);
 
16
    maxRow = Math.floor(gameCanvas.height / gameCanvas.blockSize);
 
17
    maxIndex = maxRow * maxColumn;
 
18
 
 
19
    //Close dialogs
 
20
    dialog.hide();
 
21
 
 
22
    //Initialize Board
 
23
    board = new Array(maxIndex);
 
24
    gameCanvas.score = 0;
 
25
    for (var column = 0; column < maxColumn; column++) {
 
26
        for (var row = 0; row < maxRow; row++) {
 
27
            board[index(column, row)] = null;
 
28
            createBlock(column, row);
 
29
        }
 
30
    }
 
31
}
 
32
 
 
33
function createBlock(column, row) {
 
34
    if (component == null)
 
35
        component = Qt.createComponent("Block.qml");
 
36
 
 
37
    // Note that if Block.qml was not a local file, component.status would be
 
38
    // Loading and we should wait for the component's statusChanged() signal to
 
39
    // know when the file is downloaded and ready before calling createObject().
 
40
    if (component.status == Component.Ready) {
 
41
        var dynamicObject = component.createObject(gameCanvas);
 
42
        if (dynamicObject == null) {
 
43
            console.log("error creating block");
 
44
            console.log(component.errorString());
 
45
            return false;
 
46
        }
 
47
        dynamicObject.type = Math.floor(Math.random() * 3);
 
48
        dynamicObject.x = column * gameCanvas.blockSize;
 
49
        dynamicObject.y = row * gameCanvas.blockSize;
 
50
        dynamicObject.width = gameCanvas.blockSize;
 
51
        dynamicObject.height = gameCanvas.blockSize;
 
52
        board[index(column, row)] = dynamicObject;
 
53
    } else {
 
54
        console.log("error loading block component");
 
55
        console.log(component.errorString());
 
56
        return false;
 
57
    }
 
58
    return true;
 
59
}
 
60
 
 
61
var fillFound; //Set after a floodFill call to the number of blocks found
 
62
var floodBoard; //Set to 1 if the floodFill reaches off that node
 
63
 
 
64
//![1]
 
65
function handleClick(xPos, yPos) {
 
66
    var column = Math.floor(xPos / gameCanvas.blockSize);
 
67
    var row = Math.floor(yPos / gameCanvas.blockSize);
 
68
    if (column >= maxColumn || column < 0 || row >= maxRow || row < 0)
 
69
        return;
 
70
    if (board[index(column, row)] == null)
 
71
        return;
 
72
    //If it's a valid block, remove it and all connected (does nothing if it's not connected)
 
73
    floodFill(column, row, -1);
 
74
    if (fillFound <= 0)
 
75
        return;
 
76
    gameCanvas.score += (fillFound - 1) * (fillFound - 1);
 
77
    shuffleDown();
 
78
    victoryCheck();
 
79
}
 
80
//![1]
 
81
 
 
82
function floodFill(column, row, type) {
 
83
    if (board[index(column, row)] == null)
 
84
        return;
 
85
    var first = false;
 
86
    if (type == -1) {
 
87
        first = true;
 
88
        type = board[index(column, row)].type;
 
89
 
 
90
        //Flood fill initialization
 
91
        fillFound = 0;
 
92
        floodBoard = new Array(maxIndex);
 
93
    }
 
94
    if (column >= maxColumn || column < 0 || row >= maxRow || row < 0)
 
95
        return;
 
96
    if (floodBoard[index(column, row)] == 1 || (!first && type != board[index(column, row)].type))
 
97
        return;
 
98
    floodBoard[index(column, row)] = 1;
 
99
    floodFill(column + 1, row, type);
 
100
    floodFill(column - 1, row, type);
 
101
    floodFill(column, row + 1, type);
 
102
    floodFill(column, row - 1, type);
 
103
    if (first == true && fillFound == 0)
 
104
        return;     //Can't remove single blocks
 
105
    board[index(column, row)].opacity = 0;
 
106
    board[index(column, row)] = null;
 
107
    fillFound += 1;
 
108
}
 
109
 
 
110
function shuffleDown() {
 
111
    //Fall down
 
112
    for (var column = 0; column < maxColumn; column++) {
 
113
        var fallDist = 0;
 
114
        for (var row = maxRow - 1; row >= 0; row--) {
 
115
            if (board[index(column, row)] == null) {
 
116
                fallDist += 1;
 
117
            } else {
 
118
                if (fallDist > 0) {
 
119
                    var obj = board[index(column, row)];
 
120
                    obj.y += fallDist * gameCanvas.blockSize;
 
121
                    board[index(column, row + fallDist)] = obj;
 
122
                    board[index(column, row)] = null;
 
123
                }
 
124
            }
 
125
        }
 
126
    }
 
127
    //Fall to the left
 
128
    var fallDist = 0;
 
129
    for (var column = 0; column < maxColumn; column++) {
 
130
        if (board[index(column, maxRow - 1)] == null) {
 
131
            fallDist += 1;
 
132
        } else {
 
133
            if (fallDist > 0) {
 
134
                for (var row = 0; row < maxRow; row++) {
 
135
                    var obj = board[index(column, row)];
 
136
                    if (obj == null)
 
137
                        continue;
 
138
                    obj.x -= fallDist * gameCanvas.blockSize;
 
139
                    board[index(column - fallDist, row)] = obj;
 
140
                    board[index(column, row)] = null;
 
141
                }
 
142
            }
 
143
        }
 
144
    }
 
145
}
 
146
 
 
147
//![2]
 
148
function victoryCheck() {
 
149
    //Award bonus points if no blocks left
 
150
    var deservesBonus = true;
 
151
    for (var column = maxColumn - 1; column >= 0; column--)
 
152
        if (board[index(column, maxRow - 1)] != null)
 
153
        deservesBonus = false;
 
154
    if (deservesBonus)
 
155
        gameCanvas.score += 500;
 
156
 
 
157
    //Check whether game has finished
 
158
    if (deservesBonus || !(floodMoveCheck(0, maxRow - 1, -1)))
 
159
        dialog.show("Game Over. Your score is " + gameCanvas.score);
 
160
}
 
161
//![2]
 
162
 
 
163
//only floods up and right, to see if it can find adjacent same-typed blocks 
 
164
function floodMoveCheck(column, row, type) {
 
165
    if (column >= maxColumn || column < 0 || row >= maxRow || row < 0)
 
166
        return false;
 
167
    if (board[index(column, row)] == null)
 
168
        return false;
 
169
    var myType = board[index(column, row)].type;
 
170
    if (type == myType)
 
171
        return true;
 
172
    return floodMoveCheck(column + 1, row, myType) || floodMoveCheck(column, row - 1, board[index(column, row)].type);
 
173
}
 
174