~ubuntu-branches/ubuntu/raring/gpac/raring

« back to all changes in this revision

Viewing changes to regression_tests/bifs-game-othello.bt

  • Committer: Bazaar Package Importer
  • Author(s): John Dong
  • Date: 2007-01-24 23:34:57 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20070124233457-zzlls8afkt0nyakj
Tags: 0.4.2~rc2-0ubuntu1
* New upstream release
  * Most notably MP4 tagging support via MP4Box -itags
* debian/patches/01_64bits.dpatch: dropped; included upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
InitialObjectDescriptor {
 
2
  objectDescriptorID 1
 
3
  ODProfileLevelIndication 1
 
4
  sceneProfileLevelIndication 1
 
5
  audioProfileLevelIndication 1
 
6
  visualProfileLevelIndication 1
 
7
  graphicsProfileLevelIndication 1
 
8
 
 
9
  esdescr [
 
10
    ES_Descriptor {
 
11
      es_id 1
 
12
      decConfigDescr DecoderConfigDescriptor {
 
13
                                streamType 3
 
14
                                decSpecificInfo BIFSv2Config {
 
15
                                  isCommandStream true
 
16
                                  pixelMetric true
 
17
                                  pixelWidth 400
 
18
                                  pixelHeight 400
 
19
                                }
 
20
      }
 
21
    }
 
22
  ]
 
23
}
 
24
 
 
25
OrderedGroup {
 
26
        children [
 
27
                Background2D {
 
28
                        backColor 1 1 1
 
29
                }
 
30
                DEF TimeOutSensor TimeSensor {
 
31
                        enabled FALSE
 
32
                        cycleInterval 0.15
 
33
                }                       
 
34
                Transform2D {
 
35
                        translation 0 180
 
36
                        children [
 
37
                                DEF StartTS TouchSensor {}
 
38
                                Shape {
 
39
                                        geometry Rectangle { size 100 25 }
 
40
                                        appearance Appearance { material Material2D { emissiveColor 0.5 0.5 0.5 filled TRUE } }
 
41
                                }
 
42
                                Shape { 
 
43
                                        appearance Appearance { 
 
44
                                                material Material2D { 
 
45
                                                        filled TRUE
 
46
                                                        emissiveColor 1 0 0                                     
 
47
                                                }
 
48
                                        }
 
49
                                        geometry Text { 
 
50
                                                string [ "Start Game" ]
 
51
                                                fontStyle FontStyle {
 
52
                                                        size 20                 
 
53
                                                        justify ["MIDDLE" "MIDDLE"]
 
54
                                                }
 
55
                                        }
 
56
                                }
 
57
                        ]
 
58
                }
 
59
                Switch {
 
60
                        whichChoice -1
 
61
                        choice [
 
62
                                DEF BlankPiece Transform2D {
 
63
                                        children [
 
64
                                                DEF BackRectangle Shape {
 
65
                                                        geometry DEF R Rectangle { size 42 42 }
 
66
                                                        appearance Appearance { 
 
67
                                                                material Material2D { 
 
68
                                                                        filled TRUE 
 
69
                                                                        emissiveColor 0 0.5 0.5
 
70
                                                                }
 
71
                                                        }
 
72
                                                }       
 
73
                                                Shape {
 
74
                                                        geometry DEF C Circle { radius 18 }
 
75
                                                        appearance Appearance { 
 
76
                                                                material Material2D { 
 
77
                                                                        filled TRUE 
 
78
                                                                        emissiveColor 0 0.5 0.5
 
79
                                                                }
 
80
                                                        }
 
81
                                                }
 
82
                                        ]
 
83
                                }
 
84
                                DEF WhitePiece Transform2D {
 
85
                                        children [
 
86
                                                USE BackRectangle
 
87
                                                DEF WhiteC Shape {
 
88
                                                        geometry USE C
 
89
                                                        appearance Appearance { 
 
90
                                                                material Material2D { 
 
91
                                                                        filled TRUE 
 
92
                                                                        emissiveColor 1 1 1 
 
93
                                                                } 
 
94
                                                        }
 
95
                                                }
 
96
                                        ]
 
97
                                }
 
98
                                DEF WhiteTransPiece Transform2D {
 
99
                                        children [
 
100
                                                USE BackRectangle
 
101
                                                USE WhiteC
 
102
                                        ]
 
103
                                }
 
104
                                DEF BlackPiece Transform2D {
 
105
                                        children [
 
106
                                                USE BackRectangle 
 
107
                                                DEF BlackC Shape {
 
108
                                                        geometry USE C
 
109
                                                        appearance Appearance { 
 
110
                                                                material Material2D { 
 
111
                                                                        filled TRUE 
 
112
                                                                        emissiveColor 0 0 0 
 
113
                                                                } 
 
114
                                                        }
 
115
                                                }
 
116
                                        ]
 
117
                                }
 
118
                                DEF BlackTransPiece Transform2D {
 
119
                                        children [
 
120
                                                USE BackRectangle       
 
121
                                                USE BlackC
 
122
                                        ]
 
123
                                }
 
124
                                DEF Trans1 Transform2D {
 
125
                                        children [
 
126
                                                USE BackRectangle       
 
127
                                                Shape {
 
128
                                                        geometry Text {
 
129
                                                                string [ "1" ]
 
130
                                                                fontStyle DEF TFS FontStyle {
 
131
                                                                        size 20
 
132
                                                                        justify [ "MIDDLE" "MIDDLE" ]
 
133
                                                                }
 
134
                                                        }
 
135
                                                        appearance DEF TA Appearance { 
 
136
                                                                material Material2D { 
 
137
                                                                        filled TRUE 
 
138
                                                                        emissiveColor 0 1 0 
 
139
                                                                } 
 
140
                                                        }
 
141
                                                }
 
142
                                        ]
 
143
                                }
 
144
                                DEF Trans2 Transform2D {
 
145
                                        children [
 
146
                                                USE BackRectangle       
 
147
                                                Shape {
 
148
                                                        geometry Text {
 
149
                                                                string [ "2" ]
 
150
                                                                fontStyle USE TFS
 
151
                                                        }
 
152
                                                        appearance USE TA 
 
153
                                                }
 
154
                                        ]
 
155
                                }
 
156
                                DEF Trans3 Transform2D {
 
157
                                        children [
 
158
                                                USE BackRectangle       
 
159
                                                Shape {
 
160
                                                        geometry Text {
 
161
                                                                string [ "3" ]
 
162
                                                                fontStyle USE TFS
 
163
                                                        }
 
164
                                                        appearance USE TA 
 
165
                                                }
 
166
                                        ]
 
167
                                }
 
168
                                DEF Trans4 Transform2D {
 
169
                                        children [
 
170
                                                USE BackRectangle       
 
171
                                                Shape {
 
172
                                                        geometry Text {
 
173
                                                                string [ "4" ]
 
174
                                                                fontStyle USE TFS
 
175
                                                        }
 
176
                                                        appearance USE TA 
 
177
                                                }
 
178
                                        ]
 
179
                                }
 
180
                                DEF Trans5 Transform2D {
 
181
                                        children [
 
182
                                                USE BackRectangle       
 
183
                                                Shape {
 
184
                                                        geometry Text {
 
185
                                                                string [ "5" ]
 
186
                                                                fontStyle USE TFS
 
187
                                                        }
 
188
                                                        appearance USE TA 
 
189
                                                }
 
190
                                        ]
 
191
                                }
 
192
                                DEF Trans6 Transform2D {
 
193
                                        children [
 
194
                                                USE BackRectangle       
 
195
                                                Shape {
 
196
                                                        geometry Text {
 
197
                                                                string [ "6" ]
 
198
                                                                fontStyle USE TFS
 
199
                                                        }
 
200
                                                        appearance USE TA 
 
201
                                                }
 
202
                                        ]
 
203
                                }
 
204
                                DEF Trans7 Transform2D {
 
205
                                        children [
 
206
                                                USE BackRectangle       
 
207
                                                Shape {
 
208
                                                        geometry Text {
 
209
                                                                string [ "7" ]
 
210
                                                                fontStyle USE TFS
 
211
                                                        }
 
212
                                                        appearance USE TA 
 
213
                                                }
 
214
                                        ]
 
215
                                }
 
216
                                DEF Trans8 Transform2D {
 
217
                                        children [
 
218
                                                USE BackRectangle       
 
219
                                                Shape {
 
220
                                                        geometry Text {
 
221
                                                                string [ "8" ]
 
222
                                                                fontStyle USE TFS
 
223
                                                        }
 
224
                                                        appearance USE TA 
 
225
                                                }
 
226
                                        ]
 
227
                                }
 
228
                                DEF Trans9 Transform2D {
 
229
                                        children [
 
230
                                                USE BackRectangle       
 
231
                                                Shape {
 
232
                                                        geometry Text {
 
233
                                                                string [ "9" ]
 
234
                                                                fontStyle USE TFS
 
235
                                                        }
 
236
                                                        appearance USE TA 
 
237
                                                }
 
238
                                        ]
 
239
                                }
 
240
                                DEF Trans10 Transform2D {
 
241
                                        children [
 
242
                                                USE BackRectangle       
 
243
                                                Shape {
 
244
                                                        geometry Text {
 
245
                                                                string [ "10" ]
 
246
                                                                fontStyle USE TFS
 
247
                                                        }
 
248
                                                        appearance USE TA 
 
249
                                                }
 
250
                                        ]
 
251
                                }
 
252
                                DEF Trans11 Transform2D {
 
253
                                        children [
 
254
                                                USE BackRectangle       
 
255
                                                Shape {
 
256
                                                        geometry Text {
 
257
                                                                string [ "11" ]
 
258
                                                                fontStyle USE TFS
 
259
                                                        }
 
260
                                                        appearance USE TA 
 
261
                                                }
 
262
                                        ]
 
263
                                }
 
264
                                DEF Trans12 Transform2D {
 
265
                                        children [
 
266
                                                USE BackRectangle       
 
267
                                                Shape {
 
268
                                                        geometry Text {
 
269
                                                                string [ "12" ]
 
270
                                                                fontStyle USE TFS
 
271
                                                        }
 
272
                                                        appearance USE TA 
 
273
                                                }
 
274
                                        ]
 
275
                                }
 
276
                                DEF Trans13 Transform2D {
 
277
                                        children [
 
278
                                                USE BackRectangle       
 
279
                                                Shape {
 
280
                                                        geometry Text {
 
281
                                                                string [ "13" ]
 
282
                                                                fontStyle USE TFS
 
283
                                                        }
 
284
                                                        appearance USE TA 
 
285
                                                }
 
286
                                        ]
 
287
                                }
 
288
                                DEF Trans14 Transform2D {
 
289
                                        children [
 
290
                                                USE BackRectangle       
 
291
                                                Shape {
 
292
                                                        geometry Text {
 
293
                                                                string [ "14" ]
 
294
                                                                fontStyle USE TFS
 
295
                                                        }
 
296
                                                        appearance USE TA 
 
297
                                                }
 
298
                                        ]
 
299
                                }
 
300
                                DEF Trans15 Transform2D {
 
301
                                        children [
 
302
                                                USE BackRectangle       
 
303
                                                Shape {
 
304
                                                        geometry Text {
 
305
                                                                string [ "15" ]
 
306
                                                                fontStyle USE TFS
 
307
                                                        }
 
308
                                                        appearance USE TA 
 
309
                                                }
 
310
                                        ]
 
311
                                }
 
312
                                DEF Trans16 Transform2D {
 
313
                                        children [
 
314
                                                USE BackRectangle       
 
315
                                                Shape {
 
316
                                                        geometry Text {
 
317
                                                                string [ "16" ]
 
318
                                                                fontStyle USE TFS
 
319
                                                        }
 
320
                                                        appearance USE TA 
 
321
                                                }
 
322
                                        ]
 
323
                                }
 
324
                                DEF Trans17 Transform2D {
 
325
                                        children [
 
326
                                                USE BackRectangle       
 
327
                                                Shape {
 
328
                                                        geometry Text {
 
329
                                                                string [ "17" ]
 
330
                                                                fontStyle USE TFS
 
331
                                                        }
 
332
                                                        appearance USE TA 
 
333
                                                }
 
334
                                        ]
 
335
                                }
 
336
                                DEF Trans18 Transform2D {
 
337
                                        children [
 
338
                                                USE BackRectangle       
 
339
                                                Shape {
 
340
                                                        geometry Text {
 
341
                                                                string [ "18" ]
 
342
                                                                fontStyle USE TFS
 
343
                                                        }
 
344
                                                        appearance USE TA 
 
345
                                                }
 
346
                                        ]
 
347
                                }
 
348
                                DEF Trans19 Transform2D {
 
349
                                        children [
 
350
                                                USE BackRectangle       
 
351
                                                Shape {
 
352
                                                        geometry Text {
 
353
                                                                string [ "19" ]
 
354
                                                                fontStyle USE TFS
 
355
                                                        }
 
356
                                                        appearance USE TA 
 
357
                                                }
 
358
                                        ]
 
359
                                }
 
360
                                DEF Trans20 Transform2D {
 
361
                                        children [
 
362
                                                USE BackRectangle       
 
363
                                                Shape {
 
364
                                                        geometry Text {
 
365
                                                                string [ "20" ]
 
366
                                                                fontStyle USE TFS
 
367
                                                        }
 
368
                                                        appearance USE TA 
 
369
                                                }
 
370
                                        ]
 
371
                                }
 
372
                                DEF Trans21 Transform2D {
 
373
                                        children [
 
374
                                                USE BackRectangle       
 
375
                                                Shape {
 
376
                                                        geometry Text {
 
377
                                                                string [ "21" ]
 
378
                                                                fontStyle USE TFS
 
379
                                                        }
 
380
                                                        appearance USE TA 
 
381
                                                }
 
382
                                        ]
 
383
                                }
 
384
                                
 
385
                        ]
 
386
                }
 
387
                DEF Board Form {
 
388
                        size 345 345
 
389
                        groups [ 
 
390
                                 1 -1  2 -1  3 -1  4 -1  5 -1  6 -1  7 -1  8 -1 
 
391
                                 9 -1 10 -1 11 -1 12 -1 13 -1 14 -1 15 -1 16 -1 
 
392
                                17 -1 18 -1 19 -1 20 -1 21 -1 22 -1 23 -1 24 -1
 
393
                                25 -1 26 -1 27 -1 28 -1 29 -1 30 -1 31 -1 32 -1
 
394
                                33 -1 34 -1 35 -1 36 -1 37 -1 38 -1 39 -1 40 -1
 
395
                                41 -1 42 -1 43 -1 44 -1 45 -1 46 -1 47 -1 48 -1
 
396
                                49 -1 50 -1 51 -1 52 -1 53 -1 54 -1 55 -1 56 -1
 
397
                                57 -1 58 -1 59 -1 60 -1 61 -1 62 -1 63 -1 64 -1
 
398
                                 1  2  3  4  5  6  7  8 -1 
 
399
                                 9 10 11 12 13 14 15 16 -1
 
400
                                17 18 19 20 21 22 23 24 -1
 
401
                                25 26 27 28 29 30 31 32 -1
 
402
                                33 34 35 36 37 38 39 40 -1
 
403
                                41 42 43 44 45 46 47 48 -1
 
404
                                49 50 51 52 53 54 55 56 -1
 
405
                                57 58 59 60 61 62 63 64 -1
 
406
                        ]
 
407
                        groupsIndex [ 
 
408
                                 1  2  3  4  5  6  7  8 -1 
 
409
                                 9 10 11 12 13 14 15 16 -1
 
410
                                17 18 19 20 21 22 23 24 -1
 
411
                                25 26 27 28 29 30 31 32 -1
 
412
                                33 34 35 36 37 38 39 40 -1
 
413
                                41 42 43 44 45 46 47 48 -1
 
414
                                49 50 51 52 53 54 55 56 -1
 
415
                                57 58 59 60 61 62 63 64 -1
 
416
                                65 66 67 68 69 70 71 72 -1
 
417
                        ]
 
418
                        constraints [ 
 
419
                                "SHin" 
 
420
                                "SHin" 
 
421
                                "SHin" 
 
422
                                "SHin" 
 
423
                                "SHin" 
 
424
                                "SHin" 
 
425
                                "SHin" 
 
426
                                "SHin" 
 
427
                                "SVin" 
 
428
                        ]
 
429
                        children [
 
430
                                Transform2D {
 
431
                                        children [
 
432
                                                DEF TS00 TouchSensor {}
 
433
                                                USE BlankPiece
 
434
                                                DEF V00_Over Valuator {}
 
435
                                                DEF V00_Out Valuator {}
 
436
                                                DEF V00_Click Valuator {}
 
437
                                                DEF C00_Over Conditional {
 
438
                                                        buffer {
 
439
                                                                REPLACE V00_Over.inSFVec2f BY 0 0 
 
440
                                                        }
 
441
                                                }
 
442
                                                DEF C00_Out Conditional {
 
443
                                                        buffer {
 
444
                                                                REPLACE V00_Out.inSFVec2f BY 0 0
 
445
                                                        }
 
446
                                                }
 
447
                                                DEF C00_Click Conditional {
 
448
                                                        buffer {
 
449
                                                                REPLACE V00_Click.inSFVec2f BY 0 0
 
450
                                                        }
 
451
                                                }
 
452
                                        ]
 
453
                                }
 
454
                                Transform2D {
 
455
                                        children [
 
456
                                                DEF TS01 TouchSensor {}
 
457
                                                USE BlankPiece
 
458
                                                DEF V01_Over Valuator {}
 
459
                                                DEF V01_Out Valuator {}
 
460
                                                DEF V01_Click Valuator {}
 
461
                                                DEF C01_Over Conditional {
 
462
                                                        buffer {
 
463
                                                                REPLACE V01_Over.inSFVec2f BY 0 1 
 
464
                                                        }
 
465
                                                }
 
466
                                                DEF C01_Out Conditional {
 
467
                                                        buffer {
 
468
                                                                REPLACE V01_Out.inSFVec2f BY 0 1
 
469
                                                        }
 
470
                                                }
 
471
                                                DEF C01_Click Conditional {
 
472
                                                        buffer {
 
473
                                                                REPLACE V01_Click.inSFVec2f BY 0 1
 
474
                                                        }
 
475
                                                }
 
476
                                        ]
 
477
                                }
 
478
                                Transform2D {
 
479
                                        children [
 
480
                                                DEF TS02 TouchSensor {}
 
481
                                                USE BlankPiece
 
482
                                                DEF V02_Over Valuator {}
 
483
                                                DEF V02_Out Valuator {}
 
484
                                                DEF V02_Click Valuator {}
 
485
                                                DEF C02_Over Conditional {
 
486
                                                        buffer {
 
487
                                                                REPLACE V02_Over.inSFVec2f BY 0 2 
 
488
                                                        }
 
489
                                                }
 
490
                                                DEF C02_Out Conditional {
 
491
                                                        buffer {
 
492
                                                                REPLACE V02_Out.inSFVec2f BY 0 2
 
493
                                                        }
 
494
                                                }
 
495
                                                DEF C02_Click Conditional {
 
496
                                                        buffer {
 
497
                                                                REPLACE V02_Click.inSFVec2f BY 0 2
 
498
                                                        }
 
499
                                                }
 
500
                                        ]
 
501
                                }
 
502
                                Transform2D {
 
503
                                        children [
 
504
                                                DEF TS03 TouchSensor {}
 
505
                                                USE BlankPiece
 
506
                                                DEF V03_Over Valuator {}
 
507
                                                DEF V03_Out Valuator {}
 
508
                                                DEF V03_Click Valuator {}
 
509
                                                DEF C03_Over Conditional {
 
510
                                                        buffer {
 
511
                                                                REPLACE V03_Over.inSFVec2f BY 0 3 
 
512
                                                        }
 
513
                                                }
 
514
                                                DEF C03_Out Conditional {
 
515
                                                        buffer {
 
516
                                                                REPLACE V03_Out.inSFVec2f BY 0 3
 
517
                                                        }
 
518
                                                }
 
519
                                                DEF C03_Click Conditional {
 
520
                                                        buffer {
 
521
                                                                REPLACE V03_Click.inSFVec2f BY 0 3
 
522
                                                        }
 
523
                                                }
 
524
                                        ]
 
525
                                }
 
526
                                Transform2D {
 
527
                                        children [
 
528
                                                DEF TS04 TouchSensor {}
 
529
                                                USE BlankPiece
 
530
                                                DEF V04_Over Valuator {}
 
531
                                                DEF V04_Out Valuator {}
 
532
                                                DEF V04_Click Valuator {}
 
533
                                                DEF C04_Over Conditional {
 
534
                                                        buffer {
 
535
                                                                REPLACE V04_Over.inSFVec2f BY 0 4 
 
536
                                                        }
 
537
                                                }
 
538
                                                DEF C04_Out Conditional {
 
539
                                                        buffer {
 
540
                                                                REPLACE V04_Out.inSFVec2f BY 0 4
 
541
                                                        }
 
542
                                                }
 
543
                                                DEF C04_Click Conditional {
 
544
                                                        buffer {
 
545
                                                                REPLACE V04_Click.inSFVec2f BY 0 4
 
546
                                                        }
 
547
                                                }
 
548
                                        ]
 
549
                                }
 
550
                                Transform2D {
 
551
                                        children [
 
552
                                                DEF TS05 TouchSensor {}
 
553
                                                USE BlankPiece
 
554
                                                DEF V05_Over Valuator {}
 
555
                                                DEF V05_Out Valuator {}
 
556
                                                DEF V05_Click Valuator {}
 
557
                                                DEF C05_Over Conditional {
 
558
                                                        buffer {
 
559
                                                                REPLACE V05_Over.inSFVec2f BY 0 5 
 
560
                                                        }
 
561
                                                }
 
562
                                                DEF C05_Out Conditional {
 
563
                                                        buffer {
 
564
                                                                REPLACE V05_Out.inSFVec2f BY 0 5
 
565
                                                        }
 
566
                                                }
 
567
                                                DEF C05_Click Conditional {
 
568
                                                        buffer {
 
569
                                                                REPLACE V05_Click.inSFVec2f BY 0 5
 
570
                                                        }
 
571
                                                }
 
572
                                        ]
 
573
                                }
 
574
                                Transform2D {
 
575
                                        children [
 
576
                                                DEF TS06 TouchSensor {}
 
577
                                                USE BlankPiece
 
578
                                                DEF V06_Over Valuator {}
 
579
                                                DEF V06_Out Valuator {}
 
580
                                                DEF V06_Click Valuator {}
 
581
                                                DEF C06_Over Conditional {
 
582
                                                        buffer {
 
583
                                                                REPLACE V06_Over.inSFVec2f BY 0 6 
 
584
                                                        }
 
585
                                                }
 
586
                                                DEF C06_Out Conditional {
 
587
                                                        buffer {
 
588
                                                                REPLACE V06_Out.inSFVec2f BY 0 6
 
589
                                                        }
 
590
                                                }
 
591
                                                DEF C06_Click Conditional {
 
592
                                                        buffer {
 
593
                                                                REPLACE V06_Click.inSFVec2f BY 0 6
 
594
                                                        }
 
595
                                                }
 
596
                                        ]
 
597
                                }
 
598
                                Transform2D {
 
599
                                        children [
 
600
                                                DEF TS07 TouchSensor {}
 
601
                                                USE BlankPiece
 
602
                                                DEF V07_Over Valuator {}
 
603
                                                DEF V07_Out Valuator {}
 
604
                                                DEF V07_Click Valuator {}
 
605
                                                DEF C07_Over Conditional {
 
606
                                                        buffer {
 
607
                                                                REPLACE V07_Over.inSFVec2f BY 0 7 
 
608
                                                        }
 
609
                                                }
 
610
                                                DEF C07_Out Conditional {
 
611
                                                        buffer {
 
612
                                                                REPLACE V07_Out.inSFVec2f BY 0 7
 
613
                                                        }
 
614
                                                }
 
615
                                                DEF C07_Click Conditional {
 
616
                                                        buffer {
 
617
                                                                REPLACE V07_Click.inSFVec2f BY 0 7
 
618
                                                        }
 
619
                                                }
 
620
                                        ]
 
621
                                }
 
622
                                Transform2D {
 
623
                                        children [
 
624
                                                DEF TS10 TouchSensor {}
 
625
                                                USE BlankPiece
 
626
                                                DEF V10_Over Valuator {}
 
627
                                                DEF V10_Out Valuator {}
 
628
                                                DEF V10_Click Valuator {}
 
629
                                                DEF C10_Over Conditional {
 
630
                                                        buffer {
 
631
                                                                REPLACE V10_Over.inSFVec2f BY 1 0 
 
632
                                                        }
 
633
                                                }
 
634
                                                DEF C10_Out Conditional {
 
635
                                                        buffer {
 
636
                                                                REPLACE V10_Out.inSFVec2f BY 1 0
 
637
                                                        }
 
638
                                                }
 
639
                                                DEF C10_Click Conditional {
 
640
                                                        buffer {
 
641
                                                                REPLACE V10_Click.inSFVec2f BY 1 0
 
642
                                                        }
 
643
                                                }
 
644
                                        ]
 
645
                                }
 
646
                                Transform2D {
 
647
                                        children [
 
648
                                                DEF TS11 TouchSensor {}
 
649
                                                USE BlankPiece
 
650
                                                DEF V11_Over Valuator {}
 
651
                                                DEF V11_Out Valuator {}
 
652
                                                DEF V11_Click Valuator {}
 
653
                                                DEF C11_Over Conditional {
 
654
                                                        buffer {
 
655
                                                                REPLACE V11_Over.inSFVec2f BY 1 1 
 
656
                                                        }
 
657
                                                }
 
658
                                                DEF C11_Out Conditional {
 
659
                                                        buffer {
 
660
                                                                REPLACE V11_Out.inSFVec2f BY 1 1
 
661
                                                        }
 
662
                                                }
 
663
                                                DEF C11_Click Conditional {
 
664
                                                        buffer {
 
665
                                                                REPLACE V11_Click.inSFVec2f BY 1 1
 
666
                                                        }
 
667
                                                }
 
668
                                        ]
 
669
                                }
 
670
                                Transform2D {
 
671
                                        children [
 
672
                                                DEF TS12 TouchSensor {}
 
673
                                                USE BlankPiece
 
674
                                                DEF V12_Over Valuator {}
 
675
                                                DEF V12_Out Valuator {}
 
676
                                                DEF V12_Click Valuator {}
 
677
                                                DEF C12_Over Conditional {
 
678
                                                        buffer {
 
679
                                                                REPLACE V12_Over.inSFVec2f BY 1 2 
 
680
                                                        }
 
681
                                                }
 
682
                                                DEF C12_Out Conditional {
 
683
                                                        buffer {
 
684
                                                                REPLACE V12_Out.inSFVec2f BY 1 2
 
685
                                                        }
 
686
                                                }
 
687
                                                DEF C12_Click Conditional {
 
688
                                                        buffer {
 
689
                                                                REPLACE V12_Click.inSFVec2f BY 1 2
 
690
                                                        }
 
691
                                                }
 
692
                                        ]
 
693
                                }
 
694
                                Transform2D {
 
695
                                        children [
 
696
                                                DEF TS13 TouchSensor {}
 
697
                                                USE BlankPiece
 
698
                                                DEF V13_Over Valuator {}
 
699
                                                DEF V13_Out Valuator {}
 
700
                                                DEF V13_Click Valuator {}
 
701
                                                DEF C13_Over Conditional {
 
702
                                                        buffer {
 
703
                                                                REPLACE V13_Over.inSFVec2f BY 1 3 
 
704
                                                        }
 
705
                                                }
 
706
                                                DEF C13_Out Conditional {
 
707
                                                        buffer {
 
708
                                                                REPLACE V13_Out.inSFVec2f BY 1 3
 
709
                                                        }
 
710
                                                }
 
711
                                                DEF C13_Click Conditional {
 
712
                                                        buffer {
 
713
                                                                REPLACE V13_Click.inSFVec2f BY 1 3
 
714
                                                        }
 
715
                                                }
 
716
                                        ]
 
717
                                }
 
718
                                Transform2D {
 
719
                                        children [
 
720
                                                DEF TS14 TouchSensor {}
 
721
                                                USE BlankPiece
 
722
                                                DEF V14_Over Valuator {}
 
723
                                                DEF V14_Out Valuator {}
 
724
                                                DEF V14_Click Valuator {}
 
725
                                                DEF C14_Over Conditional {
 
726
                                                        buffer {
 
727
                                                                REPLACE V14_Over.inSFVec2f BY 1 4 
 
728
                                                        }
 
729
                                                }
 
730
                                                DEF C14_Out Conditional {
 
731
                                                        buffer {
 
732
                                                                REPLACE V14_Out.inSFVec2f BY 1 4
 
733
                                                        }
 
734
                                                }
 
735
                                                DEF C14_Click Conditional {
 
736
                                                        buffer {
 
737
                                                                REPLACE V14_Click.inSFVec2f BY 1 4
 
738
                                                        }
 
739
                                                }
 
740
                                        ]
 
741
                                }
 
742
                                Transform2D {
 
743
                                        children [
 
744
                                                DEF TS15 TouchSensor {}
 
745
                                                USE BlankPiece
 
746
                                                DEF V15_Over Valuator {}
 
747
                                                DEF V15_Out Valuator {}
 
748
                                                DEF V15_Click Valuator {}
 
749
                                                DEF C15_Over Conditional {
 
750
                                                        buffer {
 
751
                                                                REPLACE V15_Over.inSFVec2f BY 1 5 
 
752
                                                        }
 
753
                                                }
 
754
                                                DEF C15_Out Conditional {
 
755
                                                        buffer {
 
756
                                                                REPLACE V15_Out.inSFVec2f BY 1 5
 
757
                                                        }
 
758
                                                }
 
759
                                                DEF C15_Click Conditional {
 
760
                                                        buffer {
 
761
                                                                REPLACE V15_Click.inSFVec2f BY 1 5
 
762
                                                        }
 
763
                                                }
 
764
                                        ]
 
765
                                }
 
766
                                Transform2D {
 
767
                                        children [
 
768
                                                DEF TS16 TouchSensor {}
 
769
                                                USE BlankPiece
 
770
                                                DEF V16_Over Valuator {}
 
771
                                                DEF V16_Out Valuator {}
 
772
                                                DEF V16_Click Valuator {}
 
773
                                                DEF C16_Over Conditional {
 
774
                                                        buffer {
 
775
                                                                REPLACE V16_Over.inSFVec2f BY 1 6 
 
776
                                                        }
 
777
                                                }
 
778
                                                DEF C16_Out Conditional {
 
779
                                                        buffer {
 
780
                                                                REPLACE V16_Out.inSFVec2f BY 1 6
 
781
                                                        }
 
782
                                                }
 
783
                                                DEF C16_Click Conditional {
 
784
                                                        buffer {
 
785
                                                                REPLACE V16_Click.inSFVec2f BY 1 6
 
786
                                                        }
 
787
                                                }
 
788
                                        ]
 
789
                                }
 
790
                                Transform2D {
 
791
                                        children [
 
792
                                                DEF TS17 TouchSensor {}
 
793
                                                USE BlankPiece
 
794
                                                DEF V17_Over Valuator {}
 
795
                                                DEF V17_Out Valuator {}
 
796
                                                DEF V17_Click Valuator {}
 
797
                                                DEF C17_Over Conditional {
 
798
                                                        buffer {
 
799
                                                                REPLACE V17_Over.inSFVec2f BY 1 7 
 
800
                                                        }
 
801
                                                }
 
802
                                                DEF C17_Out Conditional {
 
803
                                                        buffer {
 
804
                                                                REPLACE V17_Out.inSFVec2f BY 1 7
 
805
                                                        }
 
806
                                                }
 
807
                                                DEF C17_Click Conditional {
 
808
                                                        buffer {
 
809
                                                                REPLACE V17_Click.inSFVec2f BY 1 7
 
810
                                                        }
 
811
                                                }
 
812
                                        ]
 
813
                                }
 
814
                                Transform2D {
 
815
                                        children [
 
816
                                                DEF TS20 TouchSensor {}
 
817
                                                USE BlankPiece
 
818
                                                DEF V20_Over Valuator {}
 
819
                                                DEF V20_Out Valuator {}
 
820
                                                DEF V20_Click Valuator {}
 
821
                                                DEF C20_Over Conditional {
 
822
                                                        buffer {
 
823
                                                                REPLACE V20_Over.inSFVec2f BY 2 0 
 
824
                                                        }
 
825
                                                }
 
826
                                                DEF C20_Out Conditional {
 
827
                                                        buffer {
 
828
                                                                REPLACE V20_Out.inSFVec2f BY 2 0
 
829
                                                        }
 
830
                                                }
 
831
                                                DEF C20_Click Conditional {
 
832
                                                        buffer {
 
833
                                                                REPLACE V20_Click.inSFVec2f BY 2 0
 
834
                                                        }
 
835
                                                }
 
836
                                        ]
 
837
                                }
 
838
                                Transform2D {
 
839
                                        children [
 
840
                                                DEF TS21 TouchSensor {}
 
841
                                                USE BlankPiece
 
842
                                                DEF V21_Over Valuator {}
 
843
                                                DEF V21_Out Valuator {}
 
844
                                                DEF V21_Click Valuator {}
 
845
                                                DEF C21_Over Conditional {
 
846
                                                        buffer {
 
847
                                                                REPLACE V21_Over.inSFVec2f BY 2 1 
 
848
                                                        }
 
849
                                                }
 
850
                                                DEF C21_Out Conditional {
 
851
                                                        buffer {
 
852
                                                                REPLACE V21_Out.inSFVec2f BY 2 1
 
853
                                                        }
 
854
                                                }
 
855
                                                DEF C21_Click Conditional {
 
856
                                                        buffer {
 
857
                                                                REPLACE V21_Click.inSFVec2f BY 2 1
 
858
                                                        }
 
859
                                                }
 
860
                                        ]
 
861
                                }
 
862
                                Transform2D {
 
863
                                        children [
 
864
                                                DEF TS22 TouchSensor {}
 
865
                                                USE BlankPiece
 
866
                                                DEF V22_Over Valuator {}
 
867
                                                DEF V22_Out Valuator {}
 
868
                                                DEF V22_Click Valuator {}
 
869
                                                DEF C22_Over Conditional {
 
870
                                                        buffer {
 
871
                                                                REPLACE V22_Over.inSFVec2f BY 2 2 
 
872
                                                        }
 
873
                                                }
 
874
                                                DEF C22_Out Conditional {
 
875
                                                        buffer {
 
876
                                                                REPLACE V22_Out.inSFVec2f BY 2 2
 
877
                                                        }
 
878
                                                }
 
879
                                                DEF C22_Click Conditional {
 
880
                                                        buffer {
 
881
                                                                REPLACE V22_Click.inSFVec2f BY 2 2
 
882
                                                        }
 
883
                                                }
 
884
                                        ]
 
885
                                }
 
886
                                Transform2D {
 
887
                                        children [
 
888
                                                DEF TS23 TouchSensor {}
 
889
                                                USE BlankPiece
 
890
                                                DEF V23_Over Valuator {}
 
891
                                                DEF V23_Out Valuator {}
 
892
                                                DEF V23_Click Valuator {}
 
893
                                                DEF C23_Over Conditional {
 
894
                                                        buffer {
 
895
                                                                REPLACE V23_Over.inSFVec2f BY 2 3 
 
896
                                                        }
 
897
                                                }
 
898
                                                DEF C23_Out Conditional {
 
899
                                                        buffer {
 
900
                                                                REPLACE V23_Out.inSFVec2f BY 2 3
 
901
                                                        }
 
902
                                                }
 
903
                                                DEF C23_Click Conditional {
 
904
                                                        buffer {
 
905
                                                                REPLACE V23_Click.inSFVec2f BY 2 3
 
906
                                                        }
 
907
                                                }
 
908
                                        ]
 
909
                                }
 
910
                                Transform2D {
 
911
                                        children [
 
912
                                                DEF TS24 TouchSensor {}
 
913
                                                USE BlankPiece
 
914
                                                DEF V24_Over Valuator {}
 
915
                                                DEF V24_Out Valuator {}
 
916
                                                DEF V24_Click Valuator {}
 
917
                                                DEF C24_Over Conditional {
 
918
                                                        buffer {
 
919
                                                                REPLACE V24_Over.inSFVec2f BY 2 4 
 
920
                                                        }
 
921
                                                }
 
922
                                                DEF C24_Out Conditional {
 
923
                                                        buffer {
 
924
                                                                REPLACE V24_Out.inSFVec2f BY 2 4
 
925
                                                        }
 
926
                                                }
 
927
                                                DEF C24_Click Conditional {
 
928
                                                        buffer {
 
929
                                                                REPLACE V24_Click.inSFVec2f BY 2 4
 
930
                                                        }
 
931
                                                }
 
932
                                        ]
 
933
                                }
 
934
                                Transform2D {
 
935
                                        children [
 
936
                                                DEF TS25 TouchSensor {}
 
937
                                                USE BlankPiece
 
938
                                                DEF V25_Over Valuator {}
 
939
                                                DEF V25_Out Valuator {}
 
940
                                                DEF V25_Click Valuator {}
 
941
                                                DEF C25_Over Conditional {
 
942
                                                        buffer {
 
943
                                                                REPLACE V25_Over.inSFVec2f BY 2 5 
 
944
                                                        }
 
945
                                                }
 
946
                                                DEF C25_Out Conditional {
 
947
                                                        buffer {
 
948
                                                                REPLACE V25_Out.inSFVec2f BY 2 5
 
949
                                                        }
 
950
                                                }
 
951
                                                DEF C25_Click Conditional {
 
952
                                                        buffer {
 
953
                                                                REPLACE V25_Click.inSFVec2f BY 2 5
 
954
                                                        }
 
955
                                                }
 
956
                                        ]
 
957
                                }
 
958
                                Transform2D {
 
959
                                        children [
 
960
                                                DEF TS26 TouchSensor {}
 
961
                                                USE BlankPiece
 
962
                                                DEF V26_Over Valuator {}
 
963
                                                DEF V26_Out Valuator {}
 
964
                                                DEF V26_Click Valuator {}
 
965
                                                DEF C26_Over Conditional {
 
966
                                                        buffer {
 
967
                                                                REPLACE V26_Over.inSFVec2f BY 2 6 
 
968
                                                        }
 
969
                                                }
 
970
                                                DEF C26_Out Conditional {
 
971
                                                        buffer {
 
972
                                                                REPLACE V26_Out.inSFVec2f BY 2 6
 
973
                                                        }
 
974
                                                }
 
975
                                                DEF C26_Click Conditional {
 
976
                                                        buffer {
 
977
                                                                REPLACE V26_Click.inSFVec2f BY 2 6
 
978
                                                        }
 
979
                                                }
 
980
                                        ]
 
981
                                }
 
982
                                Transform2D {
 
983
                                        children [
 
984
                                                DEF TS27 TouchSensor {}
 
985
                                                USE BlankPiece
 
986
                                                DEF V27_Over Valuator {}
 
987
                                                DEF V27_Out Valuator {}
 
988
                                                DEF V27_Click Valuator {}
 
989
                                                DEF C27_Over Conditional {
 
990
                                                        buffer {
 
991
                                                                REPLACE V27_Over.inSFVec2f BY 2 7 
 
992
                                                        }
 
993
                                                }
 
994
                                                DEF C27_Out Conditional {
 
995
                                                        buffer {
 
996
                                                                REPLACE V27_Out.inSFVec2f BY 2 7
 
997
                                                        }
 
998
                                                }
 
999
                                                DEF C27_Click Conditional {
 
1000
                                                        buffer {
 
1001
                                                                REPLACE V27_Click.inSFVec2f BY 2 7
 
1002
                                                        }
 
1003
                                                }
 
1004
                                        ]
 
1005
                                }
 
1006
                                Transform2D {
 
1007
                                        children [
 
1008
                                                DEF TS30 TouchSensor {}
 
1009
                                                USE BlankPiece
 
1010
                                                DEF V30_Over Valuator {}
 
1011
                                                DEF V30_Out Valuator {}
 
1012
                                                DEF V30_Click Valuator {}
 
1013
                                                DEF C30_Over Conditional {
 
1014
                                                        buffer {
 
1015
                                                                REPLACE V30_Over.inSFVec2f BY 3 0 
 
1016
                                                        }
 
1017
                                                }
 
1018
                                                DEF C30_Out Conditional {
 
1019
                                                        buffer {
 
1020
                                                                REPLACE V30_Out.inSFVec2f BY 3 0
 
1021
                                                        }
 
1022
                                                }
 
1023
                                                DEF C30_Click Conditional {
 
1024
                                                        buffer {
 
1025
                                                                REPLACE V30_Click.inSFVec2f BY 3 0
 
1026
                                                        }
 
1027
                                                }
 
1028
                                        ]
 
1029
                                }
 
1030
                                Transform2D {
 
1031
                                        children [
 
1032
                                                DEF TS31 TouchSensor {}
 
1033
                                                USE BlankPiece
 
1034
                                                DEF V31_Over Valuator {}
 
1035
                                                DEF V31_Out Valuator {}
 
1036
                                                DEF V31_Click Valuator {}
 
1037
                                                DEF C31_Over Conditional {
 
1038
                                                        buffer {
 
1039
                                                                REPLACE V31_Over.inSFVec2f BY 3 1 
 
1040
                                                        }
 
1041
                                                }
 
1042
                                                DEF C31_Out Conditional {
 
1043
                                                        buffer {
 
1044
                                                                REPLACE V31_Out.inSFVec2f BY 3 1
 
1045
                                                        }
 
1046
                                                }
 
1047
                                                DEF C31_Click Conditional {
 
1048
                                                        buffer {
 
1049
                                                                REPLACE V31_Click.inSFVec2f BY 3 1
 
1050
                                                        }
 
1051
                                                }
 
1052
                                        ]
 
1053
                                }
 
1054
                                Transform2D {
 
1055
                                        children [
 
1056
                                                DEF TS32 TouchSensor {}
 
1057
                                                USE BlankPiece
 
1058
                                                DEF V32_Over Valuator {}
 
1059
                                                DEF V32_Out Valuator {}
 
1060
                                                DEF V32_Click Valuator {}
 
1061
                                                DEF C32_Over Conditional {
 
1062
                                                        buffer {
 
1063
                                                                REPLACE V32_Over.inSFVec2f BY 3 2 
 
1064
                                                        }
 
1065
                                                }
 
1066
                                                DEF C32_Out Conditional {
 
1067
                                                        buffer {
 
1068
                                                                REPLACE V32_Out.inSFVec2f BY 3 2
 
1069
                                                        }
 
1070
                                                }
 
1071
                                                DEF C32_Click Conditional {
 
1072
                                                        buffer {
 
1073
                                                                REPLACE V32_Click.inSFVec2f BY 3 2
 
1074
                                                        }
 
1075
                                                }
 
1076
                                        ]
 
1077
                                }
 
1078
                                Transform2D {
 
1079
                                        children [
 
1080
                                                DEF TS33 TouchSensor {}
 
1081
                                                USE WhitePiece
 
1082
                                                DEF V33_Over Valuator {}
 
1083
                                                DEF V33_Out Valuator {}
 
1084
                                                DEF V33_Click Valuator {}
 
1085
                                                DEF C33_Over Conditional {
 
1086
                                                        buffer {
 
1087
                                                                REPLACE V33_Over.inSFVec2f BY 3 3 
 
1088
                                                        }
 
1089
                                                }
 
1090
                                                DEF C33_Out Conditional {
 
1091
                                                        buffer {
 
1092
                                                                REPLACE V33_Out.inSFVec2f BY 3 3
 
1093
                                                        }
 
1094
                                                }
 
1095
                                                DEF C33_Click Conditional {
 
1096
                                                        buffer {
 
1097
                                                                REPLACE V33_Click.inSFVec2f BY 3 3
 
1098
                                                        }
 
1099
                                                }
 
1100
                                        ]
 
1101
                                }
 
1102
                                Transform2D {
 
1103
                                        children [
 
1104
                                                DEF TS34 TouchSensor {}
 
1105
                                                USE BlackPiece
 
1106
                                                DEF V34_Over Valuator {}
 
1107
                                                DEF V34_Out Valuator {}
 
1108
                                                DEF V34_Click Valuator {}
 
1109
                                                DEF C34_Over Conditional {
 
1110
                                                        buffer {
 
1111
                                                                REPLACE V34_Over.inSFVec2f BY 3 4 
 
1112
                                                        }
 
1113
                                                }
 
1114
                                                DEF C34_Out Conditional {
 
1115
                                                        buffer {
 
1116
                                                                REPLACE V34_Out.inSFVec2f BY 3 4
 
1117
                                                        }
 
1118
                                                }
 
1119
                                                DEF C34_Click Conditional {
 
1120
                                                        buffer {
 
1121
                                                                REPLACE V34_Click.inSFVec2f BY 3 4
 
1122
                                                        }
 
1123
                                                }
 
1124
                                        ]
 
1125
                                }
 
1126
                                Transform2D {
 
1127
                                        children [
 
1128
                                                DEF TS35 TouchSensor {}
 
1129
                                                USE BlankPiece
 
1130
                                                DEF V35_Over Valuator {}
 
1131
                                                DEF V35_Out Valuator {}
 
1132
                                                DEF V35_Click Valuator {}
 
1133
                                                DEF C35_Over Conditional {
 
1134
                                                        buffer {
 
1135
                                                                REPLACE V35_Over.inSFVec2f BY 3 5 
 
1136
                                                        }
 
1137
                                                }
 
1138
                                                DEF C35_Out Conditional {
 
1139
                                                        buffer {
 
1140
                                                                REPLACE V35_Out.inSFVec2f BY 3 5
 
1141
                                                        }
 
1142
                                                }
 
1143
                                                DEF C35_Click Conditional {
 
1144
                                                        buffer {
 
1145
                                                                REPLACE V35_Click.inSFVec2f BY 3 5
 
1146
                                                        }
 
1147
                                                }
 
1148
                                        ]
 
1149
                                }
 
1150
                                Transform2D {
 
1151
                                        children [
 
1152
                                                DEF TS36 TouchSensor {}
 
1153
                                                USE BlankPiece
 
1154
                                                DEF V36_Over Valuator {}
 
1155
                                                DEF V36_Out Valuator {}
 
1156
                                                DEF V36_Click Valuator {}
 
1157
                                                DEF C36_Over Conditional {
 
1158
                                                        buffer {
 
1159
                                                                REPLACE V36_Over.inSFVec2f BY 3 6 
 
1160
                                                        }
 
1161
                                                }
 
1162
                                                DEF C36_Out Conditional {
 
1163
                                                        buffer {
 
1164
                                                                REPLACE V36_Out.inSFVec2f BY 3 6
 
1165
                                                        }
 
1166
                                                }
 
1167
                                                DEF C36_Click Conditional {
 
1168
                                                        buffer {
 
1169
                                                                REPLACE V36_Click.inSFVec2f BY 3 6
 
1170
                                                        }
 
1171
                                                }
 
1172
                                        ]
 
1173
                                }
 
1174
                                Transform2D {
 
1175
                                        children [
 
1176
                                                DEF TS37 TouchSensor {}
 
1177
                                                USE BlankPiece
 
1178
                                                DEF V37_Over Valuator {}
 
1179
                                                DEF V37_Out Valuator {}
 
1180
                                                DEF V37_Click Valuator {}
 
1181
                                                DEF C37_Over Conditional {
 
1182
                                                        buffer {
 
1183
                                                                REPLACE V37_Over.inSFVec2f BY 3 7 
 
1184
                                                        }
 
1185
                                                }
 
1186
                                                DEF C37_Out Conditional {
 
1187
                                                        buffer {
 
1188
                                                                REPLACE V37_Out.inSFVec2f BY 3 7
 
1189
                                                        }
 
1190
                                                }
 
1191
                                                DEF C37_Click Conditional {
 
1192
                                                        buffer {
 
1193
                                                                REPLACE V37_Click.inSFVec2f BY 3 7
 
1194
                                                        }
 
1195
                                                }
 
1196
                                        ]
 
1197
                                }
 
1198
                                Transform2D {
 
1199
                                        children [
 
1200
                                                DEF TS40 TouchSensor {}
 
1201
                                                USE BlankPiece
 
1202
                                                DEF V40_Over Valuator {}
 
1203
                                                DEF V40_Out Valuator {}
 
1204
                                                DEF V40_Click Valuator {}
 
1205
                                                DEF C40_Over Conditional {
 
1206
                                                        buffer {
 
1207
                                                                REPLACE V40_Over.inSFVec2f BY 4 0 
 
1208
                                                        }
 
1209
                                                }
 
1210
                                                DEF C40_Out Conditional {
 
1211
                                                        buffer {
 
1212
                                                                REPLACE V40_Out.inSFVec2f BY 4 0
 
1213
                                                        }
 
1214
                                                }
 
1215
                                                DEF C40_Click Conditional {
 
1216
                                                        buffer {
 
1217
                                                                REPLACE V40_Click.inSFVec2f BY 4 0
 
1218
                                                        }
 
1219
                                                }
 
1220
                                        ]
 
1221
                                }
 
1222
                                Transform2D {
 
1223
                                        children [
 
1224
                                                DEF TS41 TouchSensor {}
 
1225
                                                USE BlankPiece
 
1226
                                                DEF V41_Over Valuator {}
 
1227
                                                DEF V41_Out Valuator {}
 
1228
                                                DEF V41_Click Valuator {}
 
1229
                                                DEF C41_Over Conditional {
 
1230
                                                        buffer {
 
1231
                                                                REPLACE V41_Over.inSFVec2f BY 4 1 
 
1232
                                                        }
 
1233
                                                }
 
1234
                                                DEF C41_Out Conditional {
 
1235
                                                        buffer {
 
1236
                                                                REPLACE V41_Out.inSFVec2f BY 4 1
 
1237
                                                        }
 
1238
                                                }
 
1239
                                                DEF C41_Click Conditional {
 
1240
                                                        buffer {
 
1241
                                                                REPLACE V41_Click.inSFVec2f BY 4 1
 
1242
                                                        }
 
1243
                                                }
 
1244
                                        ]
 
1245
                                }
 
1246
                                Transform2D {
 
1247
                                        children [
 
1248
                                                DEF TS42 TouchSensor {}
 
1249
                                                USE BlankPiece
 
1250
                                                DEF V42_Over Valuator {}
 
1251
                                                DEF V42_Out Valuator {}
 
1252
                                                DEF V42_Click Valuator {}
 
1253
                                                DEF C42_Over Conditional {
 
1254
                                                        buffer {
 
1255
                                                                REPLACE V42_Over.inSFVec2f BY 4 2 
 
1256
                                                        }
 
1257
                                                }
 
1258
                                                DEF C42_Out Conditional {
 
1259
                                                        buffer {
 
1260
                                                                REPLACE V42_Out.inSFVec2f BY 4 2
 
1261
                                                        }
 
1262
                                                }
 
1263
                                                DEF C42_Click Conditional {
 
1264
                                                        buffer {
 
1265
                                                                REPLACE V42_Click.inSFVec2f BY 4 2
 
1266
                                                        }
 
1267
                                                }
 
1268
                                        ]
 
1269
                                }
 
1270
                                Transform2D {
 
1271
                                        children [
 
1272
                                                DEF TS43 TouchSensor {}
 
1273
                                                USE BlackPiece
 
1274
                                                DEF V43_Over Valuator {}
 
1275
                                                DEF V43_Out Valuator {}
 
1276
                                                DEF V43_Click Valuator {}
 
1277
                                                DEF C43_Over Conditional {
 
1278
                                                        buffer {
 
1279
                                                                REPLACE V43_Over.inSFVec2f BY 4 3 
 
1280
                                                        }
 
1281
                                                }
 
1282
                                                DEF C43_Out Conditional {
 
1283
                                                        buffer {
 
1284
                                                                REPLACE V43_Out.inSFVec2f BY 4 3
 
1285
                                                        }
 
1286
                                                }
 
1287
                                                DEF C43_Click Conditional {
 
1288
                                                        buffer {
 
1289
                                                                REPLACE V43_Click.inSFVec2f BY 4 3
 
1290
                                                        }
 
1291
                                                }
 
1292
                                        ]
 
1293
                                }
 
1294
                                Transform2D {
 
1295
                                        children [
 
1296
                                                DEF TS44 TouchSensor {}
 
1297
                                                USE WhitePiece
 
1298
                                                DEF V44_Over Valuator {}
 
1299
                                                DEF V44_Out Valuator {}
 
1300
                                                DEF V44_Click Valuator {}
 
1301
                                                DEF C44_Over Conditional {
 
1302
                                                        buffer {
 
1303
                                                                REPLACE V44_Over.inSFVec2f BY 4 4 
 
1304
                                                        }
 
1305
                                                }
 
1306
                                                DEF C44_Out Conditional {
 
1307
                                                        buffer {
 
1308
                                                                REPLACE V44_Out.inSFVec2f BY 4 4
 
1309
                                                        }
 
1310
                                                }
 
1311
                                                DEF C44_Click Conditional {
 
1312
                                                        buffer {
 
1313
                                                                REPLACE V44_Click.inSFVec2f BY 4 4
 
1314
                                                        }
 
1315
                                                }
 
1316
                                        ]
 
1317
                                }
 
1318
                                Transform2D {
 
1319
                                        children [
 
1320
                                                DEF TS45 TouchSensor {}
 
1321
                                                USE BlankPiece
 
1322
                                                DEF V45_Over Valuator {}
 
1323
                                                DEF V45_Out Valuator {}
 
1324
                                                DEF V45_Click Valuator {}
 
1325
                                                DEF C45_Over Conditional {
 
1326
                                                        buffer {
 
1327
                                                                REPLACE V45_Over.inSFVec2f BY 4 5 
 
1328
                                                        }
 
1329
                                                }
 
1330
                                                DEF C45_Out Conditional {
 
1331
                                                        buffer {
 
1332
                                                                REPLACE V45_Out.inSFVec2f BY 4 5
 
1333
                                                        }
 
1334
                                                }
 
1335
                                                DEF C45_Click Conditional {
 
1336
                                                        buffer {
 
1337
                                                                REPLACE V45_Click.inSFVec2f BY 4 5
 
1338
                                                        }
 
1339
                                                }
 
1340
                                        ]
 
1341
                                }
 
1342
                                Transform2D {
 
1343
                                        children [
 
1344
                                                DEF TS46 TouchSensor {}
 
1345
                                                USE BlankPiece
 
1346
                                                DEF V46_Over Valuator {}
 
1347
                                                DEF V46_Out Valuator {}
 
1348
                                                DEF V46_Click Valuator {}
 
1349
                                                DEF C46_Over Conditional {
 
1350
                                                        buffer {
 
1351
                                                                REPLACE V46_Over.inSFVec2f BY 4 6 
 
1352
                                                        }
 
1353
                                                }
 
1354
                                                DEF C46_Out Conditional {
 
1355
                                                        buffer {
 
1356
                                                                REPLACE V46_Out.inSFVec2f BY 4 6
 
1357
                                                        }
 
1358
                                                }
 
1359
                                                DEF C46_Click Conditional {
 
1360
                                                        buffer {
 
1361
                                                                REPLACE V46_Click.inSFVec2f BY 4 6
 
1362
                                                        }
 
1363
                                                }
 
1364
                                        ]
 
1365
                                }
 
1366
                                Transform2D {
 
1367
                                        children [
 
1368
                                                DEF TS47 TouchSensor {}
 
1369
                                                USE BlankPiece
 
1370
                                                DEF V47_Over Valuator {}
 
1371
                                                DEF V47_Out Valuator {}
 
1372
                                                DEF V47_Click Valuator {}
 
1373
                                                DEF C47_Over Conditional {
 
1374
                                                        buffer {
 
1375
                                                                REPLACE V47_Over.inSFVec2f BY 4 7 
 
1376
                                                        }
 
1377
                                                }
 
1378
                                                DEF C47_Out Conditional {
 
1379
                                                        buffer {
 
1380
                                                                REPLACE V47_Out.inSFVec2f BY 4 7
 
1381
                                                        }
 
1382
                                                }
 
1383
                                                DEF C47_Click Conditional {
 
1384
                                                        buffer {
 
1385
                                                                REPLACE V47_Click.inSFVec2f BY 4 7
 
1386
                                                        }
 
1387
                                                }
 
1388
                                        ]
 
1389
                                }
 
1390
                                Transform2D {
 
1391
                                        children [
 
1392
                                                DEF TS50 TouchSensor {}
 
1393
                                                USE BlankPiece
 
1394
                                                DEF V50_Over Valuator {}
 
1395
                                                DEF V50_Out Valuator {}
 
1396
                                                DEF V50_Click Valuator {}
 
1397
                                                DEF C50_Over Conditional {
 
1398
                                                        buffer {
 
1399
                                                                REPLACE V50_Over.inSFVec2f BY 5 0 
 
1400
                                                        }
 
1401
                                                }
 
1402
                                                DEF C50_Out Conditional {
 
1403
                                                        buffer {
 
1404
                                                                REPLACE V50_Out.inSFVec2f BY 5 0
 
1405
                                                        }
 
1406
                                                }
 
1407
                                                DEF C50_Click Conditional {
 
1408
                                                        buffer {
 
1409
                                                                REPLACE V50_Click.inSFVec2f BY 5 0
 
1410
                                                        }
 
1411
                                                }
 
1412
                                        ]
 
1413
                                }
 
1414
                                Transform2D {
 
1415
                                        children [
 
1416
                                                DEF TS51 TouchSensor {}
 
1417
                                                USE BlankPiece
 
1418
                                                DEF V51_Over Valuator {}
 
1419
                                                DEF V51_Out Valuator {}
 
1420
                                                DEF V51_Click Valuator {}
 
1421
                                                DEF C51_Over Conditional {
 
1422
                                                        buffer {
 
1423
                                                                REPLACE V51_Over.inSFVec2f BY 5 1 
 
1424
                                                        }
 
1425
                                                }
 
1426
                                                DEF C51_Out Conditional {
 
1427
                                                        buffer {
 
1428
                                                                REPLACE V51_Out.inSFVec2f BY 5 1
 
1429
                                                        }
 
1430
                                                }
 
1431
                                                DEF C51_Click Conditional {
 
1432
                                                        buffer {
 
1433
                                                                REPLACE V51_Click.inSFVec2f BY 5 1
 
1434
                                                        }
 
1435
                                                }
 
1436
                                        ]
 
1437
                                }
 
1438
                                Transform2D {
 
1439
                                        children [
 
1440
                                                DEF TS52 TouchSensor {}
 
1441
                                                USE BlankPiece
 
1442
                                                DEF V52_Over Valuator {}
 
1443
                                                DEF V52_Out Valuator {}
 
1444
                                                DEF V52_Click Valuator {}
 
1445
                                                DEF C52_Over Conditional {
 
1446
                                                        buffer {
 
1447
                                                                REPLACE V52_Over.inSFVec2f BY 5 2 
 
1448
                                                        }
 
1449
                                                }
 
1450
                                                DEF C52_Out Conditional {
 
1451
                                                        buffer {
 
1452
                                                                REPLACE V52_Out.inSFVec2f BY 5 2
 
1453
                                                        }
 
1454
                                                }
 
1455
                                                DEF C52_Click Conditional {
 
1456
                                                        buffer {
 
1457
                                                                REPLACE V52_Click.inSFVec2f BY 5 2
 
1458
                                                        }
 
1459
                                                }
 
1460
                                        ]
 
1461
                                }
 
1462
                                Transform2D {
 
1463
                                        children [
 
1464
                                                DEF TS53 TouchSensor {}
 
1465
                                                USE BlankPiece
 
1466
                                                DEF V53_Over Valuator {}
 
1467
                                                DEF V53_Out Valuator {}
 
1468
                                                DEF V53_Click Valuator {}
 
1469
                                                DEF C53_Over Conditional {
 
1470
                                                        buffer {
 
1471
                                                                REPLACE V53_Over.inSFVec2f BY 5 3 
 
1472
                                                        }
 
1473
                                                }
 
1474
                                                DEF C53_Out Conditional {
 
1475
                                                        buffer {
 
1476
                                                                REPLACE V53_Out.inSFVec2f BY 5 3
 
1477
                                                        }
 
1478
                                                }
 
1479
                                                DEF C53_Click Conditional {
 
1480
                                                        buffer {
 
1481
                                                                REPLACE V53_Click.inSFVec2f BY 5 3
 
1482
                                                        }
 
1483
                                                }
 
1484
                                        ]
 
1485
                                }
 
1486
                                Transform2D {
 
1487
                                        children [
 
1488
                                                DEF TS54 TouchSensor {}
 
1489
                                                USE BlankPiece
 
1490
                                                DEF V54_Over Valuator {}
 
1491
                                                DEF V54_Out Valuator {}
 
1492
                                                DEF V54_Click Valuator {}
 
1493
                                                DEF C54_Over Conditional {
 
1494
                                                        buffer {
 
1495
                                                                REPLACE V54_Over.inSFVec2f BY 5 4 
 
1496
                                                        }
 
1497
                                                }
 
1498
                                                DEF C54_Out Conditional {
 
1499
                                                        buffer {
 
1500
                                                                REPLACE V54_Out.inSFVec2f BY 5 4
 
1501
                                                        }
 
1502
                                                }
 
1503
                                                DEF C54_Click Conditional {
 
1504
                                                        buffer {
 
1505
                                                                REPLACE V54_Click.inSFVec2f BY 5 4
 
1506
                                                        }
 
1507
                                                }
 
1508
                                        ]
 
1509
                                }
 
1510
                                Transform2D {
 
1511
                                        children [
 
1512
                                                DEF TS55 TouchSensor {}
 
1513
                                                USE BlankPiece
 
1514
                                                DEF V55_Over Valuator {}
 
1515
                                                DEF V55_Out Valuator {}
 
1516
                                                DEF V55_Click Valuator {}
 
1517
                                                DEF C55_Over Conditional {
 
1518
                                                        buffer {
 
1519
                                                                REPLACE V55_Over.inSFVec2f BY 5 5 
 
1520
                                                        }
 
1521
                                                }
 
1522
                                                DEF C55_Out Conditional {
 
1523
                                                        buffer {
 
1524
                                                                REPLACE V55_Out.inSFVec2f BY 5 5
 
1525
                                                        }
 
1526
                                                }
 
1527
                                                DEF C55_Click Conditional {
 
1528
                                                        buffer {
 
1529
                                                                REPLACE V55_Click.inSFVec2f BY 5 5
 
1530
                                                        }
 
1531
                                                }
 
1532
                                        ]
 
1533
                                }
 
1534
                                Transform2D {
 
1535
                                        children [
 
1536
                                                DEF TS56 TouchSensor {}
 
1537
                                                USE BlankPiece
 
1538
                                                DEF V56_Over Valuator {}
 
1539
                                                DEF V56_Out Valuator {}
 
1540
                                                DEF V56_Click Valuator {}
 
1541
                                                DEF C56_Over Conditional {
 
1542
                                                        buffer {
 
1543
                                                                REPLACE V56_Over.inSFVec2f BY 5 6 
 
1544
                                                        }
 
1545
                                                }
 
1546
                                                DEF C56_Out Conditional {
 
1547
                                                        buffer {
 
1548
                                                                REPLACE V56_Out.inSFVec2f BY 5 6
 
1549
                                                        }
 
1550
                                                }
 
1551
                                                DEF C56_Click Conditional {
 
1552
                                                        buffer {
 
1553
                                                                REPLACE V56_Click.inSFVec2f BY 5 6
 
1554
                                                        }
 
1555
                                                }
 
1556
                                        ]
 
1557
                                }
 
1558
                                Transform2D {
 
1559
                                        children [
 
1560
                                                DEF TS57 TouchSensor {}
 
1561
                                                USE BlankPiece
 
1562
                                                DEF V57_Over Valuator {}
 
1563
                                                DEF V57_Out Valuator {}
 
1564
                                                DEF V57_Click Valuator {}
 
1565
                                                DEF C57_Over Conditional {
 
1566
                                                        buffer {
 
1567
                                                                REPLACE V57_Over.inSFVec2f BY 5 7 
 
1568
                                                        }
 
1569
                                                }
 
1570
                                                DEF C57_Out Conditional {
 
1571
                                                        buffer {
 
1572
                                                                REPLACE V57_Out.inSFVec2f BY 5 7
 
1573
                                                        }
 
1574
                                                }
 
1575
                                                DEF C57_Click Conditional {
 
1576
                                                        buffer {
 
1577
                                                                REPLACE V57_Click.inSFVec2f BY 5 7
 
1578
                                                        }
 
1579
                                                }
 
1580
                                        ]
 
1581
                                }
 
1582
                                Transform2D {
 
1583
                                        children [
 
1584
                                                DEF TS60 TouchSensor {}
 
1585
                                                USE BlankPiece
 
1586
                                                DEF V60_Over Valuator {}
 
1587
                                                DEF V60_Out Valuator {}
 
1588
                                                DEF V60_Click Valuator {}
 
1589
                                                DEF C60_Over Conditional {
 
1590
                                                        buffer {
 
1591
                                                                REPLACE V60_Over.inSFVec2f BY 6 0 
 
1592
                                                        }
 
1593
                                                }
 
1594
                                                DEF C60_Out Conditional {
 
1595
                                                        buffer {
 
1596
                                                                REPLACE V60_Out.inSFVec2f BY 6 0
 
1597
                                                        }
 
1598
                                                }
 
1599
                                                DEF C60_Click Conditional {
 
1600
                                                        buffer {
 
1601
                                                                REPLACE V60_Click.inSFVec2f BY 6 0
 
1602
                                                        }
 
1603
                                                }
 
1604
                                        ]
 
1605
                                }
 
1606
                                Transform2D {
 
1607
                                        children [
 
1608
                                                DEF TS61 TouchSensor {}
 
1609
                                                USE BlankPiece
 
1610
                                                DEF V61_Over Valuator {}
 
1611
                                                DEF V61_Out Valuator {}
 
1612
                                                DEF V61_Click Valuator {}
 
1613
                                                DEF C61_Over Conditional {
 
1614
                                                        buffer {
 
1615
                                                                REPLACE V61_Over.inSFVec2f BY 6 1 
 
1616
                                                        }
 
1617
                                                }
 
1618
                                                DEF C61_Out Conditional {
 
1619
                                                        buffer {
 
1620
                                                                REPLACE V61_Out.inSFVec2f BY 6 1
 
1621
                                                        }
 
1622
                                                }
 
1623
                                                DEF C61_Click Conditional {
 
1624
                                                        buffer {
 
1625
                                                                REPLACE V61_Click.inSFVec2f BY 6 1
 
1626
                                                        }
 
1627
                                                }
 
1628
                                        ]
 
1629
                                }
 
1630
                                Transform2D {
 
1631
                                        children [
 
1632
                                                DEF TS62 TouchSensor {}
 
1633
                                                USE BlankPiece
 
1634
                                                DEF V62_Over Valuator {}
 
1635
                                                DEF V62_Out Valuator {}
 
1636
                                                DEF V62_Click Valuator {}
 
1637
                                                DEF C62_Over Conditional {
 
1638
                                                        buffer {
 
1639
                                                                REPLACE V62_Over.inSFVec2f BY 6 2 
 
1640
                                                        }
 
1641
                                                }
 
1642
                                                DEF C62_Out Conditional {
 
1643
                                                        buffer {
 
1644
                                                                REPLACE V62_Out.inSFVec2f BY 6 2
 
1645
                                                        }
 
1646
                                                }
 
1647
                                                DEF C62_Click Conditional {
 
1648
                                                        buffer {
 
1649
                                                                REPLACE V62_Click.inSFVec2f BY 6 2
 
1650
                                                        }
 
1651
                                                }
 
1652
                                        ]
 
1653
                                }
 
1654
                                Transform2D {
 
1655
                                        children [
 
1656
                                                DEF TS63 TouchSensor {}
 
1657
                                                USE BlankPiece
 
1658
                                                DEF V63_Over Valuator {}
 
1659
                                                DEF V63_Out Valuator {}
 
1660
                                                DEF V63_Click Valuator {}
 
1661
                                                DEF C63_Over Conditional {
 
1662
                                                        buffer {
 
1663
                                                                REPLACE V63_Over.inSFVec2f BY 6 3 
 
1664
                                                        }
 
1665
                                                }
 
1666
                                                DEF C63_Out Conditional {
 
1667
                                                        buffer {
 
1668
                                                                REPLACE V63_Out.inSFVec2f BY 6 3
 
1669
                                                        }
 
1670
                                                }
 
1671
                                                DEF C63_Click Conditional {
 
1672
                                                        buffer {
 
1673
                                                                REPLACE V63_Click.inSFVec2f BY 6 3
 
1674
                                                        }
 
1675
                                                }
 
1676
                                        ]
 
1677
                                }
 
1678
                                Transform2D {
 
1679
                                        children [
 
1680
                                                DEF TS64 TouchSensor {}
 
1681
                                                USE BlankPiece
 
1682
                                                DEF V64_Over Valuator {}
 
1683
                                                DEF V64_Out Valuator {}
 
1684
                                                DEF V64_Click Valuator {}
 
1685
                                                DEF C64_Over Conditional {
 
1686
                                                        buffer {
 
1687
                                                                REPLACE V64_Over.inSFVec2f BY 6 4 
 
1688
                                                        }
 
1689
                                                }
 
1690
                                                DEF C64_Out Conditional {
 
1691
                                                        buffer {
 
1692
                                                                REPLACE V64_Out.inSFVec2f BY 6 4
 
1693
                                                        }
 
1694
                                                }
 
1695
                                                DEF C64_Click Conditional {
 
1696
                                                        buffer {
 
1697
                                                                REPLACE V64_Click.inSFVec2f BY 6 4
 
1698
                                                        }
 
1699
                                                }
 
1700
                                        ]
 
1701
                                }
 
1702
                                Transform2D {
 
1703
                                        children [
 
1704
                                                DEF TS65 TouchSensor {}
 
1705
                                                USE BlankPiece
 
1706
                                                DEF V65_Over Valuator {}
 
1707
                                                DEF V65_Out Valuator {}
 
1708
                                                DEF V65_Click Valuator {}
 
1709
                                                DEF C65_Over Conditional {
 
1710
                                                        buffer {
 
1711
                                                                REPLACE V65_Over.inSFVec2f BY 6 5 
 
1712
                                                        }
 
1713
                                                }
 
1714
                                                DEF C65_Out Conditional {
 
1715
                                                        buffer {
 
1716
                                                                REPLACE V65_Out.inSFVec2f BY 6 5
 
1717
                                                        }
 
1718
                                                }
 
1719
                                                DEF C65_Click Conditional {
 
1720
                                                        buffer {
 
1721
                                                                REPLACE V65_Click.inSFVec2f BY 6 5
 
1722
                                                        }
 
1723
                                                }
 
1724
                                        ]
 
1725
                                }
 
1726
                                Transform2D {
 
1727
                                        children [
 
1728
                                                DEF TS66 TouchSensor {}
 
1729
                                                USE BlankPiece
 
1730
                                                DEF V66_Over Valuator {}
 
1731
                                                DEF V66_Out Valuator {}
 
1732
                                                DEF V66_Click Valuator {}
 
1733
                                                DEF C66_Over Conditional {
 
1734
                                                        buffer {
 
1735
                                                                REPLACE V66_Over.inSFVec2f BY 6 6 
 
1736
                                                        }
 
1737
                                                }
 
1738
                                                DEF C66_Out Conditional {
 
1739
                                                        buffer {
 
1740
                                                                REPLACE V66_Out.inSFVec2f BY 6 6
 
1741
                                                        }
 
1742
                                                }
 
1743
                                                DEF C66_Click Conditional {
 
1744
                                                        buffer {
 
1745
                                                                REPLACE V66_Click.inSFVec2f BY 6 6
 
1746
                                                        }
 
1747
                                                }
 
1748
                                        ]
 
1749
                                }
 
1750
                                Transform2D {
 
1751
                                        children [
 
1752
                                                DEF TS67 TouchSensor {}
 
1753
                                                USE BlankPiece
 
1754
                                                DEF V67_Over Valuator {}
 
1755
                                                DEF V67_Out Valuator {}
 
1756
                                                DEF V67_Click Valuator {}
 
1757
                                                DEF C67_Over Conditional {
 
1758
                                                        buffer {
 
1759
                                                                REPLACE V67_Over.inSFVec2f BY 6 7 
 
1760
                                                        }
 
1761
                                                }
 
1762
                                                DEF C67_Out Conditional {
 
1763
                                                        buffer {
 
1764
                                                                REPLACE V67_Out.inSFVec2f BY 6 7
 
1765
                                                        }
 
1766
                                                }
 
1767
                                                DEF C67_Click Conditional {
 
1768
                                                        buffer {
 
1769
                                                                REPLACE V67_Click.inSFVec2f BY 6 7
 
1770
                                                        }
 
1771
                                                }
 
1772
                                        ]
 
1773
                                }
 
1774
                                Transform2D {
 
1775
                                        children [
 
1776
                                                DEF TS70 TouchSensor {}
 
1777
                                                USE BlankPiece
 
1778
                                                DEF V70_Over Valuator {}
 
1779
                                                DEF V70_Out Valuator {}
 
1780
                                                DEF V70_Click Valuator {}
 
1781
                                                DEF C70_Over Conditional {
 
1782
                                                        buffer {
 
1783
                                                                REPLACE V70_Over.inSFVec2f BY 7 0 
 
1784
                                                        }
 
1785
                                                }
 
1786
                                                DEF C70_Out Conditional {
 
1787
                                                        buffer {
 
1788
                                                                REPLACE V70_Out.inSFVec2f BY 7 0
 
1789
                                                        }
 
1790
                                                }
 
1791
                                                DEF C70_Click Conditional {
 
1792
                                                        buffer {
 
1793
                                                                REPLACE V70_Click.inSFVec2f BY 7 0
 
1794
                                                        }
 
1795
                                                }
 
1796
                                        ]
 
1797
                                }
 
1798
                                Transform2D {
 
1799
                                        children [
 
1800
                                                DEF TS71 TouchSensor {}
 
1801
                                                USE BlankPiece
 
1802
                                                DEF V71_Over Valuator {}
 
1803
                                                DEF V71_Out Valuator {}
 
1804
                                                DEF V71_Click Valuator {}
 
1805
                                                DEF C71_Over Conditional {
 
1806
                                                        buffer {
 
1807
                                                                REPLACE V71_Over.inSFVec2f BY 7 1 
 
1808
                                                        }
 
1809
                                                }
 
1810
                                                DEF C71_Out Conditional {
 
1811
                                                        buffer {
 
1812
                                                                REPLACE V71_Out.inSFVec2f BY 7 1
 
1813
                                                        }
 
1814
                                                }
 
1815
                                                DEF C71_Click Conditional {
 
1816
                                                        buffer {
 
1817
                                                                REPLACE V71_Click.inSFVec2f BY 7 1
 
1818
                                                        }
 
1819
                                                }
 
1820
                                        ]
 
1821
                                }
 
1822
                                Transform2D {
 
1823
                                        children [
 
1824
                                                DEF TS72 TouchSensor {}
 
1825
                                                USE BlankPiece
 
1826
                                                DEF V72_Over Valuator {}
 
1827
                                                DEF V72_Out Valuator {}
 
1828
                                                DEF V72_Click Valuator {}
 
1829
                                                DEF C72_Over Conditional {
 
1830
                                                        buffer {
 
1831
                                                                REPLACE V72_Over.inSFVec2f BY 7 2 
 
1832
                                                        }
 
1833
                                                }
 
1834
                                                DEF C72_Out Conditional {
 
1835
                                                        buffer {
 
1836
                                                                REPLACE V72_Out.inSFVec2f BY 7 2
 
1837
                                                        }
 
1838
                                                }
 
1839
                                                DEF C72_Click Conditional {
 
1840
                                                        buffer {
 
1841
                                                                REPLACE V72_Click.inSFVec2f BY 7 2
 
1842
                                                        }
 
1843
                                                }
 
1844
                                        ]
 
1845
                                }
 
1846
                                Transform2D {
 
1847
                                        children [
 
1848
                                                DEF TS73 TouchSensor {}
 
1849
                                                USE BlankPiece
 
1850
                                                DEF V73_Over Valuator {}
 
1851
                                                DEF V73_Out Valuator {}
 
1852
                                                DEF V73_Click Valuator {}
 
1853
                                                DEF C73_Over Conditional {
 
1854
                                                        buffer {
 
1855
                                                                REPLACE V73_Over.inSFVec2f BY 7 3 
 
1856
                                                        }
 
1857
                                                }
 
1858
                                                DEF C73_Out Conditional {
 
1859
                                                        buffer {
 
1860
                                                                REPLACE V73_Out.inSFVec2f BY 7 3
 
1861
                                                        }
 
1862
                                                }
 
1863
                                                DEF C73_Click Conditional {
 
1864
                                                        buffer {
 
1865
                                                                REPLACE V73_Click.inSFVec2f BY 7 3
 
1866
                                                        }
 
1867
                                                }
 
1868
                                        ]
 
1869
                                }
 
1870
                                Transform2D {
 
1871
                                        children [
 
1872
                                                DEF TS74 TouchSensor {}
 
1873
                                                USE BlankPiece
 
1874
                                                DEF V74_Over Valuator {}
 
1875
                                                DEF V74_Out Valuator {}
 
1876
                                                DEF V74_Click Valuator {}
 
1877
                                                DEF C74_Over Conditional {
 
1878
                                                        buffer {
 
1879
                                                                REPLACE V74_Over.inSFVec2f BY 7 4 
 
1880
                                                        }
 
1881
                                                }
 
1882
                                                DEF C74_Out Conditional {
 
1883
                                                        buffer {
 
1884
                                                                REPLACE V74_Out.inSFVec2f BY 7 4
 
1885
                                                        }
 
1886
                                                }
 
1887
                                                DEF C74_Click Conditional {
 
1888
                                                        buffer {
 
1889
                                                                REPLACE V74_Click.inSFVec2f BY 7 4
 
1890
                                                        }
 
1891
                                                }
 
1892
                                        ]
 
1893
                                }
 
1894
                                Transform2D {
 
1895
                                        children [
 
1896
                                                DEF TS75 TouchSensor {}
 
1897
                                                USE BlankPiece
 
1898
                                                DEF V75_Over Valuator {}
 
1899
                                                DEF V75_Out Valuator {}
 
1900
                                                DEF V75_Click Valuator {}
 
1901
                                                DEF C75_Over Conditional {
 
1902
                                                        buffer {
 
1903
                                                                REPLACE V75_Over.inSFVec2f BY 7 5 
 
1904
                                                        }
 
1905
                                                }
 
1906
                                                DEF C75_Out Conditional {
 
1907
                                                        buffer {
 
1908
                                                                REPLACE V75_Out.inSFVec2f BY 7 5
 
1909
                                                        }
 
1910
                                                }
 
1911
                                                DEF C75_Click Conditional {
 
1912
                                                        buffer {
 
1913
                                                                REPLACE V75_Click.inSFVec2f BY 7 5
 
1914
                                                        }
 
1915
                                                }
 
1916
                                        ]
 
1917
                                }
 
1918
                                Transform2D {
 
1919
                                        children [
 
1920
                                                DEF TS76 TouchSensor {}
 
1921
                                                USE BlankPiece
 
1922
                                                DEF V76_Over Valuator {}
 
1923
                                                DEF V76_Out Valuator {}
 
1924
                                                DEF V76_Click Valuator {}
 
1925
                                                DEF C76_Over Conditional {
 
1926
                                                        buffer {
 
1927
                                                                REPLACE V76_Over.inSFVec2f BY 7 6 
 
1928
                                                        }
 
1929
                                                }
 
1930
                                                DEF C76_Out Conditional {
 
1931
                                                        buffer {
 
1932
                                                                REPLACE V76_Out.inSFVec2f BY 7 6
 
1933
                                                        }
 
1934
                                                }
 
1935
                                                DEF C76_Click Conditional {
 
1936
                                                        buffer {
 
1937
                                                                REPLACE V76_Click.inSFVec2f BY 7 6
 
1938
                                                        }
 
1939
                                                }
 
1940
                                        ]
 
1941
                                }
 
1942
                                Transform2D {
 
1943
                                        children [
 
1944
                                                DEF TS77 TouchSensor {}
 
1945
                                                USE BlankPiece
 
1946
                                                DEF V77_Over Valuator {}
 
1947
                                                DEF V77_Out Valuator {}
 
1948
                                                DEF V77_Click Valuator {}
 
1949
                                                DEF C77_Over Conditional {
 
1950
                                                        buffer {
 
1951
                                                                REPLACE V77_Over.inSFVec2f BY 7 7 
 
1952
                                                        }
 
1953
                                                }
 
1954
                                                DEF C77_Out Conditional {
 
1955
                                                        buffer {
 
1956
                                                                REPLACE V77_Out.inSFVec2f BY 7 7
 
1957
                                                        }
 
1958
                                                }
 
1959
                                                DEF C77_Click Conditional {
 
1960
                                                        buffer {
 
1961
                                                                REPLACE V77_Click.inSFVec2f BY 7 7
 
1962
                                                        }
 
1963
                                                }
 
1964
                                        ]
 
1965
                                }
 
1966
                        ]
 
1967
                }
 
1968
                DEF SC Script { 
 
1969
eventIn SFBool startGame
 
1970
eventIn SFVec2f mouseOver
 
1971
eventIn SFVec2f mouseOut
 
1972
eventIn SFVec2f click                   
 
1973
eventIn SFBool timeOut
 
1974
 
 
1975
field SFNode timer USE TimeOutSensor
 
1976
 
 
1977
# some internal global variables
 
1978
field MFNode picture [ 
 
1979
        USE BlankPiece
 
1980
        USE WhitePiece
 
1981
        USE BlackPiece
 
1982
        USE WhiteTransPiece
 
1983
        USE BlackTransPiece
 
1984
        USE Trans1
 
1985
        USE Trans2
 
1986
        USE Trans3
 
1987
        USE Trans4
 
1988
        USE Trans5
 
1989
        USE Trans6
 
1990
        USE Trans7
 
1991
        USE Trans8
 
1992
        USE Trans9
 
1993
        USE Trans10
 
1994
        USE Trans11
 
1995
        USE Trans12
 
1996
        USE Trans13
 
1997
        USE Trans14
 
1998
        USE Trans15
 
1999
        USE Trans16
 
2000
        USE Trans17
 
2001
        USE Trans18
 
2002
        USE Trans19
 
2003
        USE Trans20
 
2004
        USE Trans21
 
2005
]
 
2006
field SFNode images USE Board
 
2007
 
 
2008
                        url "javascript:
 
2009
// JavaScript Othello Game
 
2010
// Copyright (c) 2000, 2001 Kelly Yancey <kbyanc@posi.net>
 
2011
// All rights reserved.
 
2012
//
 
2013
// Redistribution and use in source form, with or without modification, is
 
2014
// permitted provided that the following conditions are met:
 
2015
// 1. Redistributions of source code must retain the above copyright
 
2016
//    notice, this list of conditions and the following disclaimer,
 
2017
//    without modification, immediately at the beginning of the file.
 
2018
// 2. All advertising materials mentioning features or use of this software
 
2019
//    must display the following acknowledgement:
 
2020
//      This product includes software developed by Kelly Yancey     
 
2021
//    and a reference to the URL http://www.posi.net/software/othello/
 
2022
// 3. The name of the author may not be used to endorse or promote products
 
2023
//    derived from this software without specific prior written permission.
 
2024
//    
 
2025
// THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 
2026
// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 
2027
// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  
 
2028
// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 
2029
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 
2030
// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
2031
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
2032
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT  
 
2033
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 
2034
// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
2035
 
 
2036
// picture numbers
 
2037
function initialize() {
 
2038
EMPTY = 0;              // empty square
 
2039
WHITE = 1;              // white piece
 
2040
BLACK = 2;              // black piece
 
2041
WHITETRANS = 3;         // white transparent cursor piece
 
2042
BLACKTRANS = 4;         // black transparent cursor piece
 
2043
NUMBASE = 5;            // beginning of numeric pictures
 
2044
 
 
2045
// size of the pictures used to represent pieces (all pictures must be the same size)
 
2046
piecewidth = 42;
 
2047
pieceheight = 42;
 
2048
 
 
2049
// size of the board
 
2050
width = 8;
 
2051
height = 8;
 
2052
 
 
2053
// player settings
 
2054
human = BLACK;
 
2055
showcursor = true;      // display cursor showing user where they can go
 
2056
showflips = false;      // display counts showing how many pieces they can flip by putting a piece in a given square
 
2057
 
 
2058
// AI settings
 
2059
weightsquares = 1;      // whether AI prefers squares that yield higher flip counts
 
2060
edgesensitive = 1;      // whether AI is sensitive to the importance of edge squares
 
2061
 
 
2062
// some internal global variables
 
2063
board = new Array(width);
 
2064
score = new Array();
 
2065
turn = BLACK;
 
2066
 
 
2067
 
 
2068
human = BLACK;
 
2069
showcursor = true;
 
2070
showflips = true;
 
2071
weightsquares = true;
 
2072
edgesensitive = true;
 
2073
 
 
2074
InitializeBoard();
 
2075
 
 
2076
Play(0);
 
2077
 
 
2078
}
 
2079
 
 
2080
function piece(x,y) {
 
2081
// object definition for 'piece' type
 
2082
        this.imagenum = x * width + y;
 
2083
    this.player = EMPTY;
 
2084
    // how many pieces each player could flip by taking this square
 
2085
    this.flips = new Array();
 
2086
    this.flips[WHITE] = 0;
 
2087
    this.flips[BLACK] = 0;
 
2088
    // how valuable this location is to each player
 
2089
    this.value = new Array();
 
2090
    this.value[WHITE] = 0;
 
2091
    this.value[BLACK] = 0;
 
2092
}
 
2093
 
 
2094
 
 
2095
function SetPieceImage(x, y, src) {
 
2096
// routine to set the image associated with the given piece
 
2097
    if(images.children[board[x][y].imagenum].children[1] != src) {
 
2098
                // we explicitely check to see if we are changing the image source to prevent
 
2099
                // unnecessary redrawing of images which do not change
 
2100
                images.children[board[x][y].imagenum].children[1] = src;
 
2101
    }
 
2102
}
 
2103
 
 
2104
function InitializeBoard() {
 
2105
// routine to initialize the state of the game and draw the board
 
2106
    // build the board array
 
2107
    for(x = 0; x < width; x++)
 
2108
        board[x] = new Array (height);
 
2109
 
 
2110
    for(y = 0; y < height; y++) {
 
2111
        for(x = 0; x < width; x++) {
 
2112
            // place initial pieces
 
2113
            if((x == 3 && y == 3) || (x == 4 && y == 4)) player = WHITE;
 
2114
            else if((x == 3 && y == 4) || (x == 4 && y == 3)) player = BLACK;
 
2115
            else player = EMPTY;
 
2116
            board[x][y] = new piece(x,y);
 
2117
            board[x][y].player = player;
 
2118
        }
 
2119
    }
 
2120
    // initialize scores
 
2121
    score[WHITE] = 2;
 
2122
    score[BLACK] = 2;
 
2123
}
 
2124
 
 
2125
function ResetBoard() {
 
2126
// routine to reset all of the pieces on the board
 
2127
 
 
2128
    // reset the board
 
2129
    for(y = 0; y < height; y++) {
 
2130
        for(x = 0; x < width; x++) {
 
2131
            board[x][y].player = EMPTY;
 
2132
            SetPieceImage(x, y, picture[EMPTY]);
 
2133
        }
 
2134
    }
 
2135
 
 
2136
    // reset scores
 
2137
    score[WHITE] = 0;
 
2138
    score[BLACK] = 0;
 
2139
 
 
2140
    // put initial pieces back on the board
 
2141
    RawPutPiece(3, 3, WHITE);
 
2142
    RawPutPiece(4, 4, WHITE);
 
2143
    RawPutPiece(3, 4, BLACK);
 
2144
    RawPutPiece(4, 3, BLACK);
 
2145
 
 
2146
    turn = BLACK;
 
2147
}
 
2148
 
 
2149
function NumFlips(x, y, player) {
 
2150
    count = 0;
 
2151
 
 
2152
    for(deltay = -1; deltay <= 1; deltay++) {
 
2153
        for(deltax = -1; deltax <= 1; deltax++) {
 
2154
            for(distance = 1;; distance++) {
 
2155
                posx = x + (distance * deltax);
 
2156
                posy = y + (distance * deltay);
 
2157
                // stop if we go off the board
 
2158
                if(posx < 0 || posx >= width || posy < 0 || posy >= height)
 
2159
                    break;
 
2160
                // stop when we reach an empty square
 
2161
                if(board[posx][posy].player == EMPTY)
 
2162
                    break;
 
2163
                // only update the flip count when we reach another of the
 
2164
                // player's pieces
 
2165
                if(board[posx][posy].player == player) {
 
2166
                    count += distance - 1;
 
2167
                    break;
 
2168
                }
 
2169
            }
 
2170
        }
 
2171
    }
 
2172
    return(count);
 
2173
}
 
2174
 
 
2175
function CalcFlipCounts() {
 
2176
    
 
2177
    for(y = 0; y < height; y++) {
 
2178
        for(x = 0; x < width; x++) {
 
2179
            board[x][y].flips[WHITE] = 0;
 
2180
            board[x][y].flips[BLACK] = 0;
 
2181
 
 
2182
            if(board[x][y].player != EMPTY) continue;
 
2183
 
 
2184
            board[x][y].flips[WHITE] = NumFlips(x, y, WHITE);
 
2185
            board[x][y].flips[BLACK] = NumFlips(x, y, BLACK);
 
2186
        }
 
2187
    }
 
2188
}
 
2189
 
 
2190
function RawPutPiece(x, y, player) {
 
2191
    other = OtherPlayer(player);
 
2192
    if(board[x][y].player == other) score[other]--;
 
2193
        
 
2194
    board[x][y].player = player;
 
2195
    SetPieceImage(x, y, picture[player]);
 
2196
    score[player]++;
 
2197
}
 
2198
 
 
2199
function FlipPieces(x, y, player) {
 
2200
    count = 0;
 
2201
 
 
2202
    // put a piece down at the desired location
 
2203
    RawPutPiece(x, y, player);
 
2204
 
 
2205
    for(deltay = -1; deltay <= 1; deltay++) {
 
2206
        for(deltax = -1; deltax <= 1; deltax++) {
 
2207
            for(distance = 1;; distance++) {
 
2208
                posx = x + (distance * deltax);
 
2209
                posy = y + (distance * deltay);
 
2210
                // stop if we go off the board
 
2211
                if(posx < 0 || posx >= width || posy < 0 || posy >= height)
 
2212
                    break;
 
2213
                // stop when we reach an empty square
 
2214
                if(board[posx][posy].player == EMPTY)
 
2215
                    break;
 
2216
                if(board[posx][posy].player == player) {
 
2217
                    // backtrack, flipping pieces
 
2218
                    for(distance--; distance > 0; distance--) {
 
2219
                        posx = x + (distance * deltax);
 
2220
                        posy = y + (distance * deltay);
 
2221
                        RawPutPiece(posx, posy, player);
 
2222
                    }
 
2223
                    break;
 
2224
                }
 
2225
            }
 
2226
        }
 
2227
    }
 
2228
    return(count);
 
2229
}
 
2230
 
 
2231
function AnyMoves(player) {
 
2232
    
 
2233
    for(y = 0; y < height; y++) {
 
2234
        for(x = 0; x < width; x++) {
 
2235
            if(board[x][y].player != EMPTY) continue;
 
2236
            if(NumFlips(x, y, player) > 0) return(true);
 
2237
        }
 
2238
    }
 
2239
    return(false);
 
2240
}
 
2241
 
 
2242
function CanPutPiece(x, y, player) {
 
2243
// determine whether the player can put a piece at the given position
 
2244
    if(turn != player)
 
2245
        return(false);
 
2246
    if(board[x][y].player != EMPTY)
 
2247
        return(false);
 
2248
    return(NumFlips(x, y, player) > 0);
 
2249
}
 
2250
 
 
2251
function CheckPutPiece(x, y) {    
 
2252
    if(! showcursor) return;
 
2253
    if(! CanPutPiece(x, y, human)) return;
 
2254
    if(human == WHITE) over = WHITETRANS;
 
2255
    else over = BLACKTRANS;
 
2256
 
 
2257
    SetPieceImage(x, y, picture[over]);
 
2258
}
 
2259
 
 
2260
function RestorePiece(x, y) {
 
2261
    if(showflips && RawShowFlipCount(x, y, human)) return;
 
2262
    SetPieceImage(x, y, picture[board[x][y].player]);
 
2263
}
 
2264
 
 
2265
function PutPiece(x, y, timestamp) {
 
2266
    if(! CanPutPiece(x, y, human)) return;
 
2267
 
 
2268
    FlipPieces(x, y, human);
 
2269
    DoneTurn(timestamp);
 
2270
}
 
2271
 
 
2272
function RawShowFlipCount(x, y, player) {
 
2273
    if(board[x][y].player != EMPTY) return(false);
 
2274
    if((flips = board[x][y].flips[player]) == 0) return(false);
 
2275
    SetPieceImage(x, y, picture[NUMBASE + flips]);
 
2276
    return(true);
 
2277
}
 
2278
 
 
2279
function ShowFlipCounts(player) {
 
2280
    
 
2281
    CalcFlipCounts();
 
2282
    for(y = 0; y < height; y++) {
 
2283
        for(x = 0; x < width; x++) {
 
2284
            RawShowFlipCount(x, y, player);
 
2285
        }
 
2286
    }
 
2287
}
 
2288
 
 
2289
function HideFlipCounts() {
 
2290
    
 
2291
    for(y = 0; y < height; y++) {
 
2292
        for(x = 0; x < width; x++) {
 
2293
            if(board[x][y].player == EMPTY) 
 
2294
                SetPieceImage(x, y, picture[EMPTY]);
 
2295
        }
 
2296
    }
 
2297
}
 
2298
 
 
2299
function OtherPlayer(player) {
 
2300
    return((player == WHITE)? BLACK: WHITE);
 
2301
}
 
2302
 
 
2303
function DoneTurn(timestamp) {
 
2304
        moves = AnyMoves(turn);
 
2305
        turn = OtherPlayer(turn);
 
2306
 
 
2307
    // check whether the new player has any moves
 
2308
    if(! AnyMoves(turn)) {
 
2309
        if(! moves) return(GameOver());
 
2310
        
 
2311
        // XXX inform user the player has no move
 
2312
        // and switch players again
 
2313
        turn = OtherPlayer(turn);
 
2314
    }
 
2315
 
 
2316
    // add a slight delay before the computer takes it's turn so game feels
 
2317
    // 'warmer'; when computer is playing itself, add larger delay so user
 
2318
    // can watch
 
2319
    if(turn != human) {
 
2320
        HideFlipCounts();
 
2321
        timer.cycleInterval = ((human == EMPTY)? 1: 0.150);
 
2322
        timer.startTime = timestamp;
 
2323
        timer.enabled = true;
 
2324
    } else if(showflips) ShowFlipCounts(human);
 
2325
}
 
2326
 
 
2327
function Rate(x, y, player) {
 
2328
    
 
2329
    if(board[x][y].player != EMPTY) return(0);
 
2330
    if(x < 0 || x >= width || y < 0 || y >= height) return(0);
 
2331
 
 
2332
    rating = board[x][y].flips[player];
 
2333
 
 
2334
    if(! weightsquares)
 
2335
        rating = (rating > 0)? 1: 0;
 
2336
 
 
2337
    if(edgesensitive && rating > 0) {
 
2338
        // increase all non-zero weightings by 3 so we have room
 
2339
        // to wait 'less ideal' squares below the baseline
 
2340
        rating += 10;
 
2341
 
 
2342
        // raise edge ratings 4 points, corners are raised 8
 
2343
        if(x == 0 || x == width - 1) rating += 4;
 
2344
        if(y == 0 || y == height - 1) rating += 4;
 
2345
        // lower next-to-edge ratings by 5 points, next-to-corner by 10
 
2346
        if(x == 1 || x == width - 2) rating -= 5;
 
2347
        if(y == 1 || y == height - 2) rating -= 5;
 
2348
 
 
2349
        // we cannot rule out a move because of bad location; we must
 
2350
        // always go somewhere
 
2351
        if(rating < 1) rating = 1;
 
2352
    }
 
2353
    return(rating);
 
2354
}
 
2355
 
 
2356
function OthelloAI(player, timestamp) {
 
2357
    best = 0;
 
2358
    numbest = 0;
 
2359
    
 
2360
    // rank each position on the board by the potential flip count
 
2361
    CalcFlipCounts();
 
2362
 
 
2363
    // apply AI rating algorithm
 
2364
    for(y = 0; y < height; y++) {
 
2365
        for(x = 0; x < width; x++) {
 
2366
            rating = Rate(x, y, player);
 
2367
 
 
2368
            // store the rating back into the board
 
2369
            board[x][y].value[player] = rating;
 
2370
 
 
2371
            if(rating == best)
 
2372
                numbest++;
 
2373
            else if(rating > best) {
 
2374
                best = rating;
 
2375
                numbest = 1;
 
2376
            }
 
2377
        }
 
2378
    }
 
2379
 
 
2380
    while(numbest > 0) {
 
2381
        // pick a square to put our piece
 
2382
        pick = Math.floor(Math.random() * numbest);
 
2383
        count = 0;
 
2384
        for(y = 0; y < height; y++) {
 
2385
            for(x = 0; x < width; x++) {
 
2386
                rating = board[x][y].value[player];
 
2387
                if(rating == best) {
 
2388
                    if(count == pick) {
 
2389
                        FlipPieces(x, y, player);
 
2390
                        DoneTurn(timestamp);
 
2391
                        return;
 
2392
                    }
 
2393
                    else count++;
 
2394
                }
 
2395
            }
 
2396
        }
 
2397
    }
 
2398
 
 
2399
    // if we make it here, then there was nowhere to go
 
2400
    DoneTurn(timestamp);
 
2401
}
 
2402
 
 
2403
function Play(timestamp) {
 
2404
    // black always goes first
 
2405
    if(human != BLACK)
 
2406
        OthelloAI(BLACK,timestamp);
 
2407
    else if(showflips)
 
2408
        ShowFlipCounts(human);
 
2409
}
 
2410
 
 
2411
function GameOver() {
 
2412
    turn = EMPTY;
 
2413
}
 
2414
 
 
2415
function timeOut(value, timestamp) {    
 
2416
        if (!value) {
 
2417
                OthelloAI(turn, timestamp);
 
2418
        }
 
2419
}
 
2420
 
 
2421
function startGame(value,timestamp) {   
 
2422
        if (value) {
 
2423
                Play(timestamp);
 
2424
        }
 
2425
}
 
2426
 
 
2427
function click(value, timestamp) {
 
2428
        PutPiece(value.x, value.y, timestamp);
 
2429
}
 
2430
 
 
2431
function mouseOver(value) {
 
2432
        CheckPutPiece(value.x, value.y);
 
2433
}
 
2434
 
 
2435
function mouseOut(value) {
 
2436
        RestorePiece(value.x, value.y);
 
2437
}       
 
2438
 
 
2439
                        
 
2440
                        "
 
2441
                }               
 
2442
        ]
 
2443
}
 
2444
ROUTE StartTS.isActive TO SC.startGame
 
2445
ROUTE TimeOutSensor.isActive TO SC.timeOut
 
2446
 
 
2447
ROUTE TS00.isActive TO C00_Click.activate
 
2448
ROUTE TS00.isOver TO C00_Over.activate
 
2449
ROUTE TS00.isOver TO C00_Out.reverseActivate
 
2450
ROUTE V00_Over.outSFVec2f TO SC.mouseOver
 
2451
ROUTE V00_Out.outSFVec2f TO SC.mouseOut
 
2452
ROUTE V00_Click.outSFVec2f TO SC.click
 
2453
ROUTE TS01.isActive TO C01_Click.activate
 
2454
ROUTE TS01.isOver TO C01_Over.activate
 
2455
ROUTE TS01.isOver TO C01_Out.reverseActivate
 
2456
ROUTE V01_Over.outSFVec2f TO SC.mouseOver
 
2457
ROUTE V01_Out.outSFVec2f TO SC.mouseOut
 
2458
ROUTE V01_Click.outSFVec2f TO SC.click
 
2459
ROUTE TS02.isActive TO C02_Click.activate
 
2460
ROUTE TS02.isOver TO C02_Over.activate
 
2461
ROUTE TS02.isOver TO C02_Out.reverseActivate
 
2462
ROUTE V02_Over.outSFVec2f TO SC.mouseOver
 
2463
ROUTE V02_Out.outSFVec2f TO SC.mouseOut
 
2464
ROUTE V02_Click.outSFVec2f TO SC.click
 
2465
ROUTE TS03.isActive TO C03_Click.activate
 
2466
ROUTE TS03.isOver TO C03_Over.activate
 
2467
ROUTE TS03.isOver TO C03_Out.reverseActivate
 
2468
ROUTE V03_Over.outSFVec2f TO SC.mouseOver
 
2469
ROUTE V03_Out.outSFVec2f TO SC.mouseOut
 
2470
ROUTE V03_Click.outSFVec2f TO SC.click
 
2471
ROUTE TS04.isActive TO C04_Click.activate
 
2472
ROUTE TS04.isOver TO C04_Over.activate
 
2473
ROUTE TS04.isOver TO C04_Out.reverseActivate
 
2474
ROUTE V04_Over.outSFVec2f TO SC.mouseOver
 
2475
ROUTE V04_Out.outSFVec2f TO SC.mouseOut
 
2476
ROUTE V04_Click.outSFVec2f TO SC.click
 
2477
ROUTE TS05.isActive TO C05_Click.activate
 
2478
ROUTE TS05.isOver TO C05_Over.activate
 
2479
ROUTE TS05.isOver TO C05_Out.reverseActivate
 
2480
ROUTE V05_Over.outSFVec2f TO SC.mouseOver
 
2481
ROUTE V05_Out.outSFVec2f TO SC.mouseOut
 
2482
ROUTE V05_Click.outSFVec2f TO SC.click
 
2483
ROUTE TS06.isActive TO C06_Click.activate
 
2484
ROUTE TS06.isOver TO C06_Over.activate
 
2485
ROUTE TS06.isOver TO C06_Out.reverseActivate
 
2486
ROUTE V06_Over.outSFVec2f TO SC.mouseOver
 
2487
ROUTE V06_Out.outSFVec2f TO SC.mouseOut
 
2488
ROUTE V06_Click.outSFVec2f TO SC.click
 
2489
ROUTE TS07.isActive TO C07_Click.activate
 
2490
ROUTE TS07.isOver TO C07_Over.activate
 
2491
ROUTE TS07.isOver TO C07_Out.reverseActivate
 
2492
ROUTE V07_Over.outSFVec2f TO SC.mouseOver
 
2493
ROUTE V07_Out.outSFVec2f TO SC.mouseOut
 
2494
ROUTE V07_Click.outSFVec2f TO SC.click
 
2495
ROUTE TS10.isActive TO C10_Click.activate
 
2496
ROUTE TS10.isOver TO C10_Over.activate
 
2497
ROUTE TS10.isOver TO C10_Out.reverseActivate
 
2498
ROUTE V10_Over.outSFVec2f TO SC.mouseOver
 
2499
ROUTE V10_Out.outSFVec2f TO SC.mouseOut
 
2500
ROUTE V10_Click.outSFVec2f TO SC.click
 
2501
ROUTE TS11.isActive TO C11_Click.activate
 
2502
ROUTE TS11.isOver TO C11_Over.activate
 
2503
ROUTE TS11.isOver TO C11_Out.reverseActivate
 
2504
ROUTE V11_Over.outSFVec2f TO SC.mouseOver
 
2505
ROUTE V11_Out.outSFVec2f TO SC.mouseOut
 
2506
ROUTE V11_Click.outSFVec2f TO SC.click
 
2507
ROUTE TS12.isActive TO C12_Click.activate
 
2508
ROUTE TS12.isOver TO C12_Over.activate
 
2509
ROUTE TS12.isOver TO C12_Out.reverseActivate
 
2510
ROUTE V12_Over.outSFVec2f TO SC.mouseOver
 
2511
ROUTE V12_Out.outSFVec2f TO SC.mouseOut
 
2512
ROUTE V12_Click.outSFVec2f TO SC.click
 
2513
ROUTE TS13.isActive TO C13_Click.activate
 
2514
ROUTE TS13.isOver TO C13_Over.activate
 
2515
ROUTE TS13.isOver TO C13_Out.reverseActivate
 
2516
ROUTE V13_Over.outSFVec2f TO SC.mouseOver
 
2517
ROUTE V13_Out.outSFVec2f TO SC.mouseOut
 
2518
ROUTE V13_Click.outSFVec2f TO SC.click
 
2519
ROUTE TS14.isActive TO C14_Click.activate
 
2520
ROUTE TS14.isOver TO C14_Over.activate
 
2521
ROUTE TS14.isOver TO C14_Out.reverseActivate
 
2522
ROUTE V14_Over.outSFVec2f TO SC.mouseOver
 
2523
ROUTE V14_Out.outSFVec2f TO SC.mouseOut
 
2524
ROUTE V14_Click.outSFVec2f TO SC.click
 
2525
ROUTE TS15.isActive TO C15_Click.activate
 
2526
ROUTE TS15.isOver TO C15_Over.activate
 
2527
ROUTE TS15.isOver TO C15_Out.reverseActivate
 
2528
ROUTE V15_Over.outSFVec2f TO SC.mouseOver
 
2529
ROUTE V15_Out.outSFVec2f TO SC.mouseOut
 
2530
ROUTE V15_Click.outSFVec2f TO SC.click
 
2531
ROUTE TS16.isActive TO C16_Click.activate
 
2532
ROUTE TS16.isOver TO C16_Over.activate
 
2533
ROUTE TS16.isOver TO C16_Out.reverseActivate
 
2534
ROUTE V16_Over.outSFVec2f TO SC.mouseOver
 
2535
ROUTE V16_Out.outSFVec2f TO SC.mouseOut
 
2536
ROUTE V16_Click.outSFVec2f TO SC.click
 
2537
ROUTE TS17.isActive TO C17_Click.activate
 
2538
ROUTE TS17.isOver TO C17_Over.activate
 
2539
ROUTE TS17.isOver TO C17_Out.reverseActivate
 
2540
ROUTE V17_Over.outSFVec2f TO SC.mouseOver
 
2541
ROUTE V17_Out.outSFVec2f TO SC.mouseOut
 
2542
ROUTE V17_Click.outSFVec2f TO SC.click
 
2543
ROUTE TS20.isActive TO C20_Click.activate
 
2544
ROUTE TS20.isOver TO C20_Over.activate
 
2545
ROUTE TS20.isOver TO C20_Out.reverseActivate
 
2546
ROUTE V20_Over.outSFVec2f TO SC.mouseOver
 
2547
ROUTE V20_Out.outSFVec2f TO SC.mouseOut
 
2548
ROUTE V20_Click.outSFVec2f TO SC.click
 
2549
ROUTE TS21.isActive TO C21_Click.activate
 
2550
ROUTE TS21.isOver TO C21_Over.activate
 
2551
ROUTE TS21.isOver TO C21_Out.reverseActivate
 
2552
ROUTE V21_Over.outSFVec2f TO SC.mouseOver
 
2553
ROUTE V21_Out.outSFVec2f TO SC.mouseOut
 
2554
ROUTE V21_Click.outSFVec2f TO SC.click
 
2555
ROUTE TS22.isActive TO C22_Click.activate
 
2556
ROUTE TS22.isOver TO C22_Over.activate
 
2557
ROUTE TS22.isOver TO C22_Out.reverseActivate
 
2558
ROUTE V22_Over.outSFVec2f TO SC.mouseOver
 
2559
ROUTE V22_Out.outSFVec2f TO SC.mouseOut
 
2560
ROUTE V22_Click.outSFVec2f TO SC.click
 
2561
ROUTE TS23.isActive TO C23_Click.activate
 
2562
ROUTE TS23.isOver TO C23_Over.activate
 
2563
ROUTE TS23.isOver TO C23_Out.reverseActivate
 
2564
ROUTE V23_Over.outSFVec2f TO SC.mouseOver
 
2565
ROUTE V23_Out.outSFVec2f TO SC.mouseOut
 
2566
ROUTE V23_Click.outSFVec2f TO SC.click
 
2567
ROUTE TS24.isActive TO C24_Click.activate
 
2568
ROUTE TS24.isOver TO C24_Over.activate
 
2569
ROUTE TS24.isOver TO C24_Out.reverseActivate
 
2570
ROUTE V24_Over.outSFVec2f TO SC.mouseOver
 
2571
ROUTE V24_Out.outSFVec2f TO SC.mouseOut
 
2572
ROUTE V24_Click.outSFVec2f TO SC.click
 
2573
ROUTE TS25.isActive TO C25_Click.activate
 
2574
ROUTE TS25.isOver TO C25_Over.activate
 
2575
ROUTE TS25.isOver TO C25_Out.reverseActivate
 
2576
ROUTE V25_Over.outSFVec2f TO SC.mouseOver
 
2577
ROUTE V25_Out.outSFVec2f TO SC.mouseOut
 
2578
ROUTE V25_Click.outSFVec2f TO SC.click
 
2579
ROUTE TS26.isActive TO C26_Click.activate
 
2580
ROUTE TS26.isOver TO C26_Over.activate
 
2581
ROUTE TS26.isOver TO C26_Out.reverseActivate
 
2582
ROUTE V26_Over.outSFVec2f TO SC.mouseOver
 
2583
ROUTE V26_Out.outSFVec2f TO SC.mouseOut
 
2584
ROUTE V26_Click.outSFVec2f TO SC.click
 
2585
ROUTE TS27.isActive TO C27_Click.activate
 
2586
ROUTE TS27.isOver TO C27_Over.activate
 
2587
ROUTE TS27.isOver TO C27_Out.reverseActivate
 
2588
ROUTE V27_Over.outSFVec2f TO SC.mouseOver
 
2589
ROUTE V27_Out.outSFVec2f TO SC.mouseOut
 
2590
ROUTE V27_Click.outSFVec2f TO SC.click
 
2591
ROUTE TS30.isActive TO C30_Click.activate
 
2592
ROUTE TS30.isOver TO C30_Over.activate
 
2593
ROUTE TS30.isOver TO C30_Out.reverseActivate
 
2594
ROUTE V30_Over.outSFVec2f TO SC.mouseOver
 
2595
ROUTE V30_Out.outSFVec2f TO SC.mouseOut
 
2596
ROUTE V30_Click.outSFVec2f TO SC.click
 
2597
ROUTE TS31.isActive TO C31_Click.activate
 
2598
ROUTE TS31.isOver TO C31_Over.activate
 
2599
ROUTE TS31.isOver TO C31_Out.reverseActivate
 
2600
ROUTE V31_Over.outSFVec2f TO SC.mouseOver
 
2601
ROUTE V31_Out.outSFVec2f TO SC.mouseOut
 
2602
ROUTE V31_Click.outSFVec2f TO SC.click
 
2603
ROUTE TS32.isActive TO C32_Click.activate
 
2604
ROUTE TS32.isOver TO C32_Over.activate
 
2605
ROUTE TS32.isOver TO C32_Out.reverseActivate
 
2606
ROUTE V32_Over.outSFVec2f TO SC.mouseOver
 
2607
ROUTE V32_Out.outSFVec2f TO SC.mouseOut
 
2608
ROUTE V32_Click.outSFVec2f TO SC.click
 
2609
ROUTE TS33.isActive TO C33_Click.activate
 
2610
ROUTE TS33.isOver TO C33_Over.activate
 
2611
ROUTE TS33.isOver TO C33_Out.reverseActivate
 
2612
ROUTE V33_Over.outSFVec2f TO SC.mouseOver
 
2613
ROUTE V33_Out.outSFVec2f TO SC.mouseOut
 
2614
ROUTE V33_Click.outSFVec2f TO SC.click
 
2615
ROUTE TS34.isActive TO C34_Click.activate
 
2616
ROUTE TS34.isOver TO C34_Over.activate
 
2617
ROUTE TS34.isOver TO C34_Out.reverseActivate
 
2618
ROUTE V34_Over.outSFVec2f TO SC.mouseOver
 
2619
ROUTE V34_Out.outSFVec2f TO SC.mouseOut
 
2620
ROUTE V34_Click.outSFVec2f TO SC.click
 
2621
ROUTE TS35.isActive TO C35_Click.activate
 
2622
ROUTE TS35.isOver TO C35_Over.activate
 
2623
ROUTE TS35.isOver TO C35_Out.reverseActivate
 
2624
ROUTE V35_Over.outSFVec2f TO SC.mouseOver
 
2625
ROUTE V35_Out.outSFVec2f TO SC.mouseOut
 
2626
ROUTE V35_Click.outSFVec2f TO SC.click
 
2627
ROUTE TS36.isActive TO C36_Click.activate
 
2628
ROUTE TS36.isOver TO C36_Over.activate
 
2629
ROUTE TS36.isOver TO C36_Out.reverseActivate
 
2630
ROUTE V36_Over.outSFVec2f TO SC.mouseOver
 
2631
ROUTE V36_Out.outSFVec2f TO SC.mouseOut
 
2632
ROUTE V36_Click.outSFVec2f TO SC.click
 
2633
ROUTE TS37.isActive TO C37_Click.activate
 
2634
ROUTE TS37.isOver TO C37_Over.activate
 
2635
ROUTE TS37.isOver TO C37_Out.reverseActivate
 
2636
ROUTE V37_Over.outSFVec2f TO SC.mouseOver
 
2637
ROUTE V37_Out.outSFVec2f TO SC.mouseOut
 
2638
ROUTE V37_Click.outSFVec2f TO SC.click
 
2639
ROUTE TS40.isActive TO C40_Click.activate
 
2640
ROUTE TS40.isOver TO C40_Over.activate
 
2641
ROUTE TS40.isOver TO C40_Out.reverseActivate
 
2642
ROUTE V40_Over.outSFVec2f TO SC.mouseOver
 
2643
ROUTE V40_Out.outSFVec2f TO SC.mouseOut
 
2644
ROUTE V40_Click.outSFVec2f TO SC.click
 
2645
ROUTE TS41.isActive TO C41_Click.activate
 
2646
ROUTE TS41.isOver TO C41_Over.activate
 
2647
ROUTE TS41.isOver TO C41_Out.reverseActivate
 
2648
ROUTE V41_Over.outSFVec2f TO SC.mouseOver
 
2649
ROUTE V41_Out.outSFVec2f TO SC.mouseOut
 
2650
ROUTE V41_Click.outSFVec2f TO SC.click
 
2651
ROUTE TS42.isActive TO C42_Click.activate
 
2652
ROUTE TS42.isOver TO C42_Over.activate
 
2653
ROUTE TS42.isOver TO C42_Out.reverseActivate
 
2654
ROUTE V42_Over.outSFVec2f TO SC.mouseOver
 
2655
ROUTE V42_Out.outSFVec2f TO SC.mouseOut
 
2656
ROUTE V42_Click.outSFVec2f TO SC.click
 
2657
ROUTE TS43.isActive TO C43_Click.activate
 
2658
ROUTE TS43.isOver TO C43_Over.activate
 
2659
ROUTE TS43.isOver TO C43_Out.reverseActivate
 
2660
ROUTE V43_Over.outSFVec2f TO SC.mouseOver
 
2661
ROUTE V43_Out.outSFVec2f TO SC.mouseOut
 
2662
ROUTE V43_Click.outSFVec2f TO SC.click
 
2663
ROUTE TS44.isActive TO C44_Click.activate
 
2664
ROUTE TS44.isOver TO C44_Over.activate
 
2665
ROUTE TS44.isOver TO C44_Out.reverseActivate
 
2666
ROUTE V44_Over.outSFVec2f TO SC.mouseOver
 
2667
ROUTE V44_Out.outSFVec2f TO SC.mouseOut
 
2668
ROUTE V44_Click.outSFVec2f TO SC.click
 
2669
ROUTE TS45.isActive TO C45_Click.activate
 
2670
ROUTE TS45.isOver TO C45_Over.activate
 
2671
ROUTE TS45.isOver TO C45_Out.reverseActivate
 
2672
ROUTE V45_Over.outSFVec2f TO SC.mouseOver
 
2673
ROUTE V45_Out.outSFVec2f TO SC.mouseOut
 
2674
ROUTE V45_Click.outSFVec2f TO SC.click
 
2675
ROUTE TS46.isActive TO C46_Click.activate
 
2676
ROUTE TS46.isOver TO C46_Over.activate
 
2677
ROUTE TS46.isOver TO C46_Out.reverseActivate
 
2678
ROUTE V46_Over.outSFVec2f TO SC.mouseOver
 
2679
ROUTE V46_Out.outSFVec2f TO SC.mouseOut
 
2680
ROUTE V46_Click.outSFVec2f TO SC.click
 
2681
ROUTE TS47.isActive TO C47_Click.activate
 
2682
ROUTE TS47.isOver TO C47_Over.activate
 
2683
ROUTE TS47.isOver TO C47_Out.reverseActivate
 
2684
ROUTE V47_Over.outSFVec2f TO SC.mouseOver
 
2685
ROUTE V47_Out.outSFVec2f TO SC.mouseOut
 
2686
ROUTE V47_Click.outSFVec2f TO SC.click
 
2687
ROUTE TS50.isActive TO C50_Click.activate
 
2688
ROUTE TS50.isOver TO C50_Over.activate
 
2689
ROUTE TS50.isOver TO C50_Out.reverseActivate
 
2690
ROUTE V50_Over.outSFVec2f TO SC.mouseOver
 
2691
ROUTE V50_Out.outSFVec2f TO SC.mouseOut
 
2692
ROUTE V50_Click.outSFVec2f TO SC.click
 
2693
ROUTE TS51.isActive TO C51_Click.activate
 
2694
ROUTE TS51.isOver TO C51_Over.activate
 
2695
ROUTE TS51.isOver TO C51_Out.reverseActivate
 
2696
ROUTE V51_Over.outSFVec2f TO SC.mouseOver
 
2697
ROUTE V51_Out.outSFVec2f TO SC.mouseOut
 
2698
ROUTE V51_Click.outSFVec2f TO SC.click
 
2699
ROUTE TS52.isActive TO C52_Click.activate
 
2700
ROUTE TS52.isOver TO C52_Over.activate
 
2701
ROUTE TS52.isOver TO C52_Out.reverseActivate
 
2702
ROUTE V52_Over.outSFVec2f TO SC.mouseOver
 
2703
ROUTE V52_Out.outSFVec2f TO SC.mouseOut
 
2704
ROUTE V52_Click.outSFVec2f TO SC.click
 
2705
ROUTE TS53.isActive TO C53_Click.activate
 
2706
ROUTE TS53.isOver TO C53_Over.activate
 
2707
ROUTE TS53.isOver TO C53_Out.reverseActivate
 
2708
ROUTE V53_Over.outSFVec2f TO SC.mouseOver
 
2709
ROUTE V53_Out.outSFVec2f TO SC.mouseOut
 
2710
ROUTE V53_Click.outSFVec2f TO SC.click
 
2711
ROUTE TS54.isActive TO C54_Click.activate
 
2712
ROUTE TS54.isOver TO C54_Over.activate
 
2713
ROUTE TS54.isOver TO C54_Out.reverseActivate
 
2714
ROUTE V54_Over.outSFVec2f TO SC.mouseOver
 
2715
ROUTE V54_Out.outSFVec2f TO SC.mouseOut
 
2716
ROUTE V54_Click.outSFVec2f TO SC.click
 
2717
ROUTE TS55.isActive TO C55_Click.activate
 
2718
ROUTE TS55.isOver TO C55_Over.activate
 
2719
ROUTE TS55.isOver TO C55_Out.reverseActivate
 
2720
ROUTE V55_Over.outSFVec2f TO SC.mouseOver
 
2721
ROUTE V55_Out.outSFVec2f TO SC.mouseOut
 
2722
ROUTE V55_Click.outSFVec2f TO SC.click
 
2723
ROUTE TS56.isActive TO C56_Click.activate
 
2724
ROUTE TS56.isOver TO C56_Over.activate
 
2725
ROUTE TS56.isOver TO C56_Out.reverseActivate
 
2726
ROUTE V56_Over.outSFVec2f TO SC.mouseOver
 
2727
ROUTE V56_Out.outSFVec2f TO SC.mouseOut
 
2728
ROUTE V56_Click.outSFVec2f TO SC.click
 
2729
ROUTE TS57.isActive TO C57_Click.activate
 
2730
ROUTE TS57.isOver TO C57_Over.activate
 
2731
ROUTE TS57.isOver TO C57_Out.reverseActivate
 
2732
ROUTE V57_Over.outSFVec2f TO SC.mouseOver
 
2733
ROUTE V57_Out.outSFVec2f TO SC.mouseOut
 
2734
ROUTE V57_Click.outSFVec2f TO SC.click
 
2735
ROUTE TS60.isActive TO C60_Click.activate
 
2736
ROUTE TS60.isOver TO C60_Over.activate
 
2737
ROUTE TS60.isOver TO C60_Out.reverseActivate
 
2738
ROUTE V60_Over.outSFVec2f TO SC.mouseOver
 
2739
ROUTE V60_Out.outSFVec2f TO SC.mouseOut
 
2740
ROUTE V60_Click.outSFVec2f TO SC.click
 
2741
ROUTE TS61.isActive TO C61_Click.activate
 
2742
ROUTE TS61.isOver TO C61_Over.activate
 
2743
ROUTE TS61.isOver TO C61_Out.reverseActivate
 
2744
ROUTE V61_Over.outSFVec2f TO SC.mouseOver
 
2745
ROUTE V61_Out.outSFVec2f TO SC.mouseOut
 
2746
ROUTE V61_Click.outSFVec2f TO SC.click
 
2747
ROUTE TS62.isActive TO C62_Click.activate
 
2748
ROUTE TS62.isOver TO C62_Over.activate
 
2749
ROUTE TS62.isOver TO C62_Out.reverseActivate
 
2750
ROUTE V62_Over.outSFVec2f TO SC.mouseOver
 
2751
ROUTE V62_Out.outSFVec2f TO SC.mouseOut
 
2752
ROUTE V62_Click.outSFVec2f TO SC.click
 
2753
ROUTE TS63.isActive TO C63_Click.activate
 
2754
ROUTE TS63.isOver TO C63_Over.activate
 
2755
ROUTE TS63.isOver TO C63_Out.reverseActivate
 
2756
ROUTE V63_Over.outSFVec2f TO SC.mouseOver
 
2757
ROUTE V63_Out.outSFVec2f TO SC.mouseOut
 
2758
ROUTE V63_Click.outSFVec2f TO SC.click
 
2759
ROUTE TS64.isActive TO C64_Click.activate
 
2760
ROUTE TS64.isOver TO C64_Over.activate
 
2761
ROUTE TS64.isOver TO C64_Out.reverseActivate
 
2762
ROUTE V64_Over.outSFVec2f TO SC.mouseOver
 
2763
ROUTE V64_Out.outSFVec2f TO SC.mouseOut
 
2764
ROUTE V64_Click.outSFVec2f TO SC.click
 
2765
ROUTE TS65.isActive TO C65_Click.activate
 
2766
ROUTE TS65.isOver TO C65_Over.activate
 
2767
ROUTE TS65.isOver TO C65_Out.reverseActivate
 
2768
ROUTE V65_Over.outSFVec2f TO SC.mouseOver
 
2769
ROUTE V65_Out.outSFVec2f TO SC.mouseOut
 
2770
ROUTE V65_Click.outSFVec2f TO SC.click
 
2771
ROUTE TS66.isActive TO C66_Click.activate
 
2772
ROUTE TS66.isOver TO C66_Over.activate
 
2773
ROUTE TS66.isOver TO C66_Out.reverseActivate
 
2774
ROUTE V66_Over.outSFVec2f TO SC.mouseOver
 
2775
ROUTE V66_Out.outSFVec2f TO SC.mouseOut
 
2776
ROUTE V66_Click.outSFVec2f TO SC.click
 
2777
ROUTE TS67.isActive TO C67_Click.activate
 
2778
ROUTE TS67.isOver TO C67_Over.activate
 
2779
ROUTE TS67.isOver TO C67_Out.reverseActivate
 
2780
ROUTE V67_Over.outSFVec2f TO SC.mouseOver
 
2781
ROUTE V67_Out.outSFVec2f TO SC.mouseOut
 
2782
ROUTE V67_Click.outSFVec2f TO SC.click
 
2783
ROUTE TS70.isActive TO C70_Click.activate
 
2784
ROUTE TS70.isOver TO C70_Over.activate
 
2785
ROUTE TS70.isOver TO C70_Out.reverseActivate
 
2786
ROUTE V70_Over.outSFVec2f TO SC.mouseOver
 
2787
ROUTE V70_Out.outSFVec2f TO SC.mouseOut
 
2788
ROUTE V70_Click.outSFVec2f TO SC.click
 
2789
ROUTE TS71.isActive TO C71_Click.activate
 
2790
ROUTE TS71.isOver TO C71_Over.activate
 
2791
ROUTE TS71.isOver TO C71_Out.reverseActivate
 
2792
ROUTE V71_Over.outSFVec2f TO SC.mouseOver
 
2793
ROUTE V71_Out.outSFVec2f TO SC.mouseOut
 
2794
ROUTE V71_Click.outSFVec2f TO SC.click
 
2795
ROUTE TS72.isActive TO C72_Click.activate
 
2796
ROUTE TS72.isOver TO C72_Over.activate
 
2797
ROUTE TS72.isOver TO C72_Out.reverseActivate
 
2798
ROUTE V72_Over.outSFVec2f TO SC.mouseOver
 
2799
ROUTE V72_Out.outSFVec2f TO SC.mouseOut
 
2800
ROUTE V72_Click.outSFVec2f TO SC.click
 
2801
ROUTE TS73.isActive TO C73_Click.activate
 
2802
ROUTE TS73.isOver TO C73_Over.activate
 
2803
ROUTE TS73.isOver TO C73_Out.reverseActivate
 
2804
ROUTE V73_Over.outSFVec2f TO SC.mouseOver
 
2805
ROUTE V73_Out.outSFVec2f TO SC.mouseOut
 
2806
ROUTE V73_Click.outSFVec2f TO SC.click
 
2807
ROUTE TS74.isActive TO C74_Click.activate
 
2808
ROUTE TS74.isOver TO C74_Over.activate
 
2809
ROUTE TS74.isOver TO C74_Out.reverseActivate
 
2810
ROUTE V74_Over.outSFVec2f TO SC.mouseOver
 
2811
ROUTE V74_Out.outSFVec2f TO SC.mouseOut
 
2812
ROUTE V74_Click.outSFVec2f TO SC.click
 
2813
ROUTE TS75.isActive TO C75_Click.activate
 
2814
ROUTE TS75.isOver TO C75_Over.activate
 
2815
ROUTE TS75.isOver TO C75_Out.reverseActivate
 
2816
ROUTE V75_Over.outSFVec2f TO SC.mouseOver
 
2817
ROUTE V75_Out.outSFVec2f TO SC.mouseOut
 
2818
ROUTE V75_Click.outSFVec2f TO SC.click
 
2819
ROUTE TS76.isActive TO C76_Click.activate
 
2820
ROUTE TS76.isOver TO C76_Over.activate
 
2821
ROUTE TS76.isOver TO C76_Out.reverseActivate
 
2822
ROUTE V76_Over.outSFVec2f TO SC.mouseOver
 
2823
ROUTE V76_Out.outSFVec2f TO SC.mouseOut
 
2824
ROUTE V76_Click.outSFVec2f TO SC.click
 
2825
ROUTE TS77.isActive TO C77_Click.activate
 
2826
ROUTE TS77.isOver TO C77_Over.activate
 
2827
ROUTE TS77.isOver TO C77_Out.reverseActivate
 
2828
ROUTE V77_Over.outSFVec2f TO SC.mouseOver
 
2829
ROUTE V77_Out.outSFVec2f TO SC.mouseOut
 
2830
ROUTE V77_Click.outSFVec2f TO SC.click