← Back to branch summary

~ubuntu-branches/ubuntu/natty/plee-the-bear/natty

« back to all changes in this revision

Viewing changes to plee-the-bear/data/gfx/ray/ray-1.scm

  • Committer: Bazaar Package Importer
  • Author(s): Julien Jorge, Julien Jorge
  • Date: 2010-11-17 20:13:34 UTC
  • mfrom: (6.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20101117201334-o4dp7uq437to7oxb
Tags: 0.5.1-1
http://bugs.debian.org/565062
http://bugs.debian.org/546514
http://bugs.debian.org/604689
[ Julien Jorge ]
* New upstream release (Closes: #565062, #546514).
* Add armhf architecture (Closes: #604689).
* Remove patches integrated upstream: rpath-editors.diff, rpath-game.diff,
  editors-menu-section.diff.
* Bump the Standard-Version, no changes.
* Update my email address.
* Set build dependency of libclaw to 1.6.0.
* Add the missing ${misc:Depends} in debian/control.
* List gettext translations in bear-factory.install and plee-the-bear.install.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plee-the-bear/data/gfx/ray/ray-1.scm
 
1
;
 
2
;  Plee the Bear -- gfx script tools
 
3
;
 
4
;  Copyright (C) 2005-2010 Julien Jorge, Sebastien Angibaud
 
5
;
 
6
;  This program is free software; you can redistribute it and/or modify it
 
7
;  under the terms of the GNU General Public License as published by the
 
8
;  Free Software Foundation; either version 2 of the License, or (at your
 
9
;  option) any later version.
 
10
;
 
11
;  This program is distributed in the hope that it will be useful, but WITHOUT
 
12
;  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 
13
;  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 
14
;  more details.
 
15
;
 
16
;  You should have received a copy of the GNU General Public License along
 
17
;  with this program; if not, write to the Free Software Foundation, Inc.,
 
18
;  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
19
;
 
20
;  contact: plee-the-bear@gamned.org
 
21
;
 
22
;  Please add the tag [PTB] in the subject of your mails.
 
23
;
 
24
; --
 
25
;
 
26
; This script is intended to be run in this directory and via gimp-console:
 
27
;
 
28
;   gimp-console -b - < this_script.scm
 
29
;
 
30
(load "../../common.scm")
 
31
 
 
32
(define idle-ray
 
33
  (lambda (dest_image)
 
34
    ; the ratio of the size is 0.38
 
35
 
 
36
    (let ( (src_name "ray-idle.xcf.bz2") )
 
37
      (let ( (src_image (car (gimp-file-load 1 src_name src_name)))
 
38
             )
 
39
 
 
40
        ; layer names
 
41
        (let ( (head       0)
 
42
               (arm        1)
 
43
               (arm_shadow 2)
 
44
               (pant       3)
 
45
               (body       4)
 
46
               (feet       5) )
 
47
 
 
48
          (create-layer src_image
 
49
                        (list head arm arm_shadow pant body feet)
 
50
                        0 0 28 87 dest_image)
 
51
          ); let
 
52
        ); let
 
53
      ); let
 
54
    ); lambda
 
55
  ); define idle-ray
 
56
 
 
57
(define walking-ray
 
58
  (lambda (dest_image)
 
59
    ; the ratio of the size is 0.38
 
60
 
 
61
    (let ( (src_name "ray-walking.xcf.bz2") )
 
62
      (let ( (src_image (car (gimp-file-load 1 src_name src_name)))
 
63
             )
 
64
 
 
65
        ; layer names
 
66
        (let ( (right_arm_toward        0)
 
67
               (right_arm_bit_toward    1)
 
68
               (right_arm_bit_backward  2)
 
69
               (right_arm_backward      3)
 
70
               (head                    4)
 
71
               (body                    5)
 
72
               (right_leg               6)
 
73
               (right_leg_backward      7)
 
74
               (right_leg_up            8)
 
75
               (right_leg_toward        9)
 
76
               (left_leg               10)
 
77
               (left_leg_backward      11)
 
78
               (left_leg_up            12)
 
79
               (left_leg_toward        13)
 
80
               (left_arm_bit_backward  14)
 
81
               (left_arm_backward      15) )
 
82
 
 
83
          (create-layer src_image
 
84
                        (list head body right_arm_backward
 
85
                              right_leg_toward left_leg)
 
86
                        28 0 55 87 dest_image)
 
87
          (create-layer src_image
 
88
                        (list head body right_arm_bit_backward
 
89
                              right_leg_toward left_leg_backward)
 
90
                        83 0 55 87 dest_image)
 
91
          (create-layer src_image
 
92
                        (list head body right_arm_bit_toward
 
93
                              right_leg left_leg_backward left_arm_bit_backward)
 
94
                        138 0 55 87 dest_image)
 
95
          (create-layer src_image
 
96
                        (list head body right_arm_toward
 
97
                              right_leg left_leg_up left_arm_backward)
 
98
                        193 0 55 87 dest_image)
 
99
          (create-layer src_image
 
100
                        (list head body right_arm_toward
 
101
                              right_leg left_leg_toward left_arm_bit_backward)
 
102
                        248 0 55 87 dest_image)
 
103
          (create-layer src_image
 
104
                        (list head body right_arm_bit_toward
 
105
                              right_leg_backward left_leg_toward)
 
106
                        303 0 55 87 dest_image)
 
107
          (create-layer src_image
 
108
                        (list head body right_arm_bit_backward
 
109
                              right_leg_backward left_leg)
 
110
                        358 0 55 87 dest_image)
 
111
          (create-layer src_image
 
112
                        (list head body right_arm_backward
 
113
                              right_leg_up left_leg)
 
114
                        413 0 55 87 dest_image)
 
115
          ) ; let
 
116
        ) ; let
 
117
      ) ; let
 
118
    ) ; lambda
 
119
  ) ; define walking-ray
 
120
 
 
121
(define looking-upward-ray
 
122
  (lambda (dest_image)
 
123
    ; the ratio of the size is 0.38
 
124
 
 
125
    (let ( (src_name "ray-look-up.xcf.bz2") )
 
126
      (let ( (src_image (car (gimp-file-load 1 src_name src_name)))
 
127
             )
 
128
 
 
129
        ; layer names
 
130
        (let ( (arm        0)
 
131
               (arm_shadow 1)
 
132
               (head       2)
 
133
               (pant       3)
 
134
               (body       4)
 
135
               (feet       5) )
 
136
 
 
137
          (create-layer src_image
 
138
                        (list head arm arm_shadow pant body feet)
 
139
                        468 0 27 91 dest_image)
 
140
          ); let
 
141
        ); let
 
142
      ); let
 
143
    ); lambda
 
144
  ); define looking-upward-ray
 
145
 
 
146
(define walking-crying-ray
 
147
  (lambda (dest_image)
 
148
    ; the ratio of the size is 0.38
 
149
 
 
150
    (let ( (src_name "ray-crying.xcf.bz2") )
 
151
      (let ( (src_image (car (gimp-file-load 1 src_name src_name)))
 
152
             )
 
153
 
 
154
        ; layer names
 
155
        (let ( (right_arm_backward  0)
 
156
               (tears_1             1)
 
157
               (tears_2             2)
 
158
               (tears_3             3)
 
159
               (tears_4             4)
 
160
               (head                5)
 
161
               (body                6)
 
162
               (right_leg           7)
 
163
               (right_leg_backward  8)
 
164
               (left_leg            9)
 
165
               (left_leg_backward  10) )
 
166
 
 
167
          ; walking
 
168
          (create-layer src_image
 
169
                        (list right_arm_backward head body tears_1
 
170
                              right_leg left_leg)
 
171
                        0 87 41 90 dest_image)
 
172
          (create-layer src_image
 
173
                        (list right_arm_backward head body tears_2
 
174
                              right_leg left_leg_backward)
 
175
                        41 87 41 90 dest_image)
 
176
          (create-layer src_image
 
177
                        (list right_arm_backward head body tears_3
 
178
                              right_leg left_leg)
 
179
                        82 87 41 90 dest_image)
 
180
          (create-layer src_image
 
181
                        (list right_arm_backward head body tears_4
 
182
                              right_leg_backward left_leg)
 
183
                        123 87 41 90 dest_image)
 
184
 
 
185
          ; idle
 
186
          (create-layer-crop src_image
 
187
                             (list right_arm_backward head body tears_1
 
188
                                   right_leg left_leg)
 
189
                             37 0 71 236
 
190
                             164 87 27 90 dest_image '())
 
191
          (create-layer-crop src_image
 
192
                             (list right_arm_backward head body tears_2
 
193
                                   right_leg left_leg)
 
194
                             37 0 71 236
 
195
                             191 87 27 90 dest_image '())
 
196
          (create-layer-crop src_image
 
197
                             (list right_arm_backward head body tears_3
 
198
                                   right_leg left_leg)
 
199
                             37 0 71 236
 
200
                             218 87 27 90 dest_image '())
 
201
          (create-layer-crop src_image
 
202
                             (list right_arm_backward head body tears_4
 
203
                                   right_leg left_leg)
 
204
                             37 0 71 236
 
205
                             245 87 27 90 dest_image '())
 
206
          ) ; let
 
207
        ) ; let
 
208
      ) ; let
 
209
    ) ; lambda
 
210
  ) ; define walking-crying-ray
 
211
 
 
212
(define jumping-ray
 
213
  (lambda (dest_image)
 
214
    ; the ratio of the size is 0.38
 
215
 
 
216
    (let ( (src_name "ray-jumping.xcf.bz2") )
 
217
      (let ( (src_image (car (gimp-file-load 1 src_name src_name)))
 
218
             )
 
219
 
 
220
        ; layer names
 
221
        (let ( (right_arm_up           0)
 
222
               (head_up                1)
 
223
               (right_leg_up           2)
 
224
               (left_leg_up            3)
 
225
               (body_up                4)
 
226
               (left_arm_up            5)
 
227
 
 
228
               (right_arm_push         6)
 
229
               (right_arm_push_shadow  7)
 
230
               (head_push              8)
 
231
               (right_leg_push         9)
 
232
               (body_push             10)
 
233
               (left_leg_push         11)
 
234
               (left_arm_push         12)
 
235
 
 
236
               (right_arm_init        13)
 
237
               (right_arm_init_shadow 14)
 
238
               (head_init             15)
 
239
               (right_leg_init        16)
 
240
               (left_leg_init         17)
 
241
               (body_init             18) )
 
242
               
 
243
          (create-layer src_image
 
244
                        (list right_arm_init right_arm_init_shadow head_init
 
245
                              right_leg_init left_leg_init body_init)
 
246
                        272 87 39 95 dest_image)
 
247
          (create-layer src_image
 
248
                        (list right_arm_push right_arm_push_shadow head_push
 
249
                              right_leg_push body_push left_leg_push
 
250
                              left_arm_push)
 
251
                        311 87 39 95 dest_image)
 
252
          (create-layer src_image
 
253
                        (list right_arm_up head_up right_leg_up left_leg_up
 
254
                              body_up left_arm_up)
 
255
                        350 87 39 95 dest_image)
 
256
          ); let
 
257
        ); let
 
258
      ); let
 
259
    ); lambda
 
260
  ); define jumping-ray
 
261
 
 
262
(define falling-ray
 
263
  (lambda (dest_image)
 
264
    ; the ratio of the size is 0.38
 
265
 
 
266
    (let ( (src_name "ray-falling.xcf.bz2") )
 
267
      (let ( (src_image (car (gimp-file-load 1 src_name src_name)))
 
268
             )
 
269
 
 
270
        ; layer names
 
271
        (let ( (right_arm_back         0)
 
272
               (right_arm_back_shadow  1)
 
273
               (right_arm              2)
 
274
               (right_arm_shadow       3)
 
275
               (right_arm_front        4)
 
276
               (right_arm_front_shadow 5)
 
277
               (head_back              6)
 
278
               (head                   7)
 
279
               (head_front             8)
 
280
               (right_leg_back         9)
 
281
               (right_leg             10)
 
282
               (right_leg_front       11)
 
283
               (left_leg_back         12)
 
284
               (left_leg              13)
 
285
               (left_leg_front        14)
 
286
               (body_back             15)
 
287
               (body                  16)
 
288
               (body_front            17)
 
289
               (left_arm_back         18)
 
290
               (left_arm              19)
 
291
               (left_arm_front        20) )
 
292
               
 
293
          (create-layer src_image
 
294
                        (list right_arm_back right_arm_back_shadow head_back
 
295
                              right_leg_back left_leg_back
 
296
                              body_back left_arm_back)
 
297
                        389 87 40 86 dest_image)
 
298
          (create-layer src_image
 
299
                        (list right_arm right_arm_shadow head
 
300
                              right_leg left_leg
 
301
                              body left_arm)
 
302
                        429 91 40 86 dest_image)
 
303
          (create-layer src_image
 
304
                        (list right_arm_front right_arm_front_shadow head_front
 
305
                              right_leg_front left_leg_front
 
306
                              body_front left_arm_front)
 
307
                        469 91 40 86 dest_image)
 
308
          ); let
 
309
        ); let
 
310
      ); let
 
311
    ); lambda
 
312
  ); define falling-ray
 
313
 
 
314
(define injured-ray
 
315
  (lambda (dest_image)
 
316
    ; the ratio of the size is 0.38
 
317
 
 
318
    (let ( (src_name "ray-injured.xcf.bz2") )
 
319
      (let ( (src_image (car (gimp-file-load 1 src_name src_name)))
 
320
             )
 
321
 
 
322
        ; layer names
 
323
        (let ( (head 0)
 
324
               (body 1) )
 
325
               
 
326
          (create-layer src_image
 
327
                        (list body head)
 
328
                        0 177 43 81 dest_image)
 
329
          ); let
 
330
        ); let
 
331
      ); let
 
332
    ); lambda
 
333
  ); define injured-ray
 
334
 
 
335
(let ( (dest_name "ray-1.png") )
 
336
  (let ( (dest_image (car (gimp-image-new 512 512 RGB))) )
 
337
    (let ( (bk (car (gimp-layer-new dest_image 512 512 1 "background" 100 0)))
 
338
           )
 
339
      (gimp-image-add-layer dest_image bk 0)
 
340
      )
 
341
 
 
342
    (idle-ray dest_image)
 
343
    (walking-ray dest_image)
 
344
    (looking-upward-ray dest_image)
 
345
    (walking-crying-ray dest_image)
 
346
    (jumping-ray dest_image)
 
347
    (falling-ray dest_image)
 
348
    (injured-ray dest_image)
 
349
 
 
350
    (save-frames-and-exit dest_name dest_image)
 
351
    ) ; let
 
352
  ) ; let