1 /*
2 * sact.c: SACT
3 *
4 * Copyright (C) 1997-1998 Masaki Chikama (Wren) <chikama@kasumi.ipl.mech.nagoya-u.ac.jp>
5 * 1998- <masaki-c@is.aist-nara.ac.jp>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 */
22 /* $Id: SACT.c,v 1.10 2004/10/31 04:18:02 chikama Exp $ */
23
24 #include "config.h"
25
26 #include <stdio.h>
27 #include <string.h>
28 #include <glib.h>
29
30 #include "portab.h"
31 #include "system.h"
32 #include "imput.h"
33 #include "xsystem35.h"
34 #include "gametitle.h"
35 #include "message.h"
36 #include "nact.h"
37 #include "sact.h"
38 #include "sprite.h"
39 #include "sactcg.h"
40 #include "sactstring.h"
41 #include "sactsound.h"
42 #include "sactbgm.h"
43 #include "sactcrypto.h"
44 #include "sactchart.h"
45 #include "ngraph.h"
46 #include "surface.h"
47 #include "sactamask.h"
48
49 /*
50 MT���ޥ�ɤ����ꤵ�줿ʸ����ˤ�äơ��С������֤ΰ㤤��ۼ�
51
52 Version 1.0 : �������쥤�䡼
53 1.1 : Rance5D
54 1.2(����): �ʤߤ�����
55 1.2(���): SACT��ȯ���å�, �����롦���쥤��, NightDemon
56 */
57
58 /*
59 �ʤߤ�������������
60
61 ��å����������å�(���ɡ�̤�ɴط��ʤ������å�) -> Ctrl
62 ��ư��å��������� -> A����
63 A�����������Ȥǡ���ưŪ�˥�å�������������ǹԤ��ޤ���(��ư��å�����
64 ���꤬ON�ˤʤ�ȡ���å�����������ɤα����ˤ��������Ԥ���������(>>>>)��
65 �ä��ޤ������������ϡ�����դ⤷���ϲ�����λ�ޤǡ�A��������³����
66 ����������A������Υ�����Ȥ��ˡ������Ԥ��������뤬ɽ�������в�����줿
67 ���Ȥˤʤ�ޤ���
68 �Хå��� -> �ۥ�����
69 */
70
71
72 /*
73 wNum ���ϰϤʤɡ������Υ����å��ϳƥ��֥����ƥ��Ǥ��롣
74
75
76 ������ǧ����
77 SACT.CreateSprite �Ϥ��θƤФ줿�ִ֤�CG�����Ѥ����
78 ->SACT.Draw�ޤǤ�CG���ѹ�����Ƥ⡢Create����CG�����
79 OutputMessage�ϥ�å�������ɽ������ޤǤ�ɤäƤ��ʤ���
80 QuakeScreen�Ͻ�λ�ޤǤ�ɤäƤ��ʤ���(����ȴ������)
81 ��ư���ԤϤ��ʤ�
82 OutputMessage �����ƻϤ�ƣ�ʸ���Ť������Ԥ���NewLine�ǤϽ��ʤ���
83 ~KEY 2: ��ľ�������Ƥ�SP_MOVE����λ����ޤǥ����å����ץ饤������ȿ�����ʤ�
84 drag��˥����å����ץ饤�Ȥ�ȿ�����ʤ�
85 ���˥������ץ饤�ȤϤĤͤ�ư��
86 �����å����ץ饤�Ȥϡ��ܥ����������֤ǥ��ץ饤��������ä��褿�Ȥ��⡢
87 cg3���Ѳ����롣���ΤȤ��ܥ����Υ���Ƥ� SpriteKeyWait��ȴ���ʤ���
88 �ޤ����ܥ���������ޤޥ��ץ饤�ȳ��˽ФƤ⡢�Ф����cg1���Ѳ�����
89 GETA/B��ե������������CG2�˥ܥ�������CG3��
90 SWPUT�ϥܥ�������ȴ����
91 */
92
93
94 // SACT ��Ϣ�ξ���
95 sact_t sactprv;
96 extern char *xsys35_sact01;
97
98 /**
99 * SACT.Init (1.0~)
100 * SACT���Τν����
101 */
Init()102 void Init() {
103 int p1 = getCaliValue(); /* ISys3x */
104
105 // �����ॿ���ȥ�ˤ��С����������
106 if (0 == strcmp(nact->game_title_name, GT_ESUKA)) {
107 sact.version = 100;
108 } else if (0 == strcmp(nact->game_title_name, GT_RANCE5D)){
109 sact.version = 110;
110 } else {
111 sact.version = 120;
112 }
113
114 NOTICE("SACT version = %d\n", sact.version);
115
116 // �����ɸ����
117 sact.origin.x = 0;
118 sact.origin.y = 0;
119
120 // �ƥ��֥����ƥ�����
121 sp_init();
122 sstr_init();
123 ssel_init();
124 stimer_init();
125 ssnd_init();
126
127 if (nact->files.sact01) {
128 smask_init(nact->files.sact01);
129 }
130
131 // create depth map
132 sact.dmap = sf_create_pixel(sf0->width, sf0->height, 16);
133
134 // ����¾ System35 �Υǥե����ư����ѹ�
135 nact->ags.font->antialiase_on = TRUE;
136 sys_setHankakuMode(2); // ����Ⱦ���Ѵ�̵��
137 ags_autorepeat(FALSE); // key auto repeat off
138
139 if (sact.version >= 120) {
140 sact.logging = TRUE;
141 } else {
142 sact.logging = FALSE;
143 }
144
145 DEBUG_COMMAND("SACT.Init %d:\n", p1);
146 }
147
148 /**
149 * SACT.CreateSprite (1.0~)
150 * ���ץ饤�Ⱥ���
151 * @param wNum: ���ץ饤���ֹ�
152 * @param wNumCG1: �̾�ɽ������ã��ֹ�
153 * @param wNumCG2: �ޥ������������Ťͤ��Ȥ��Σã��ֹ�
154 * @param wNumCG3: ����å������Ȥ��Σã��ֹ�
155 * @param wType: ���ץ饤�ȤΥ�����
156 */
CreateSprite()157 void CreateSprite() {
158 int wNum = getCaliValue();
159 int wNumCG1 = getCaliValue();
160 int wNumCG2 = getCaliValue();
161 int wNumCG3 = getCaliValue();
162 int wType = getCaliValue();
163
164 sp_new(wNum, wNumCG1, wNumCG2, wNumCG3, wType);
165
166 DEBUG_COMMAND_YET("SACT.CreateSprite %d,%d,%d,%d,%d:\n", wNum, wNumCG1, wNumCG2, wNumCG3, wType);
167 }
168
169 /**
170 * SACT.CreateTextSprite (1.0~)
171 * ��å�������ɽ�����륹�ץ饤�Ȥκ���
172 * @param wNum: ���ץ饤���ֹ�
173 * @param wX: ɽ�����֤Σغ�ɸ
174 * @param wY: ɽ�����֤Σٺ�ɸ
175 * @param wWidth: ���ץ饤�Ȥ���
176 * @param wHeight: ���ץ饤�Ȥι⤵
177 */
CreateTextSprite()178 void CreateTextSprite() {
179 int wNum = getCaliValue();
180 int wX = getCaliValue();
181 int wY = getCaliValue();
182 int wWidth = getCaliValue();
183 int wHeight = getCaliValue();
184
185 sp_new_msg(wNum, wX, wY, wWidth, wHeight);
186
187 DEBUG_COMMAND_YET("SACT.CreateTextSprite %d,%d,%d,%d,%d:\n", wNum, wX, wY, wWidth, wHeight);
188 }
189
190 /**
191 * SACT.SetWallPaper (1.0~)
192 * �ɻ�(�����ط�)�Ȥ���ɽ������ãǤ�����
193 * @param wNum: �ɻ�(�ط�)�Ȥ���ɽ������ãǤ��ֹ�
194 */
SetWallPaper()195 void SetWallPaper() {
196 int wNum = getCaliValue();
197
198 sp_set_wall_paper(wNum);
199
200 DEBUG_COMMAND_YET("SACT.SetWallPaper %d:\n", wNum);
201 }
202
203 /**
204 * SACT.Clear (1.0~)
205 * �����ץ饤�Ⱥ��(~SP_CLR)
206 */
Clear()207 void Clear() {
208 sp_free_all();
209
210 DEBUG_COMMAND_YET("SACT.Clear:\n");
211 }
212
213 /**
214 * SACT.Delete (1.0~)
215 * ���ץ饤�Ȥκ��
216 * @param wNum: ������륹�ץ饤���ֹ�
217 */
Delete()218 void Delete() {
219 int wNum = getCaliValue();
220
221 sp_free(wNum);
222
223 DEBUG_COMMAND_YET("SACT.Delete %d:\n", wNum);
224 }
225
226 /**
227 * SACT.SpriteDeleteCount (1.0~)
228 * wNum�֤���wCount�Ĥ��ϰϤΥ��ץ饤�Ȥκ��
229 * @param wNum: ��Ƭ���ץ饤���ֹ�
230 * @param wCount: �ϰ�
231 */
SpriteDeleteCount()232 void SpriteDeleteCount() {
233 int wNum = getCaliValue();
234 int wCount = getCaliValue();
235 int i;
236
237 for (i = wNum; i < (wNum + wCount); i++) {
238 sp_free(i);
239 }
240
241 DEBUG_COMMAND_YET("SACT.SpriteDeleteCount %d,%d:\n", wNum, wCount);
242 }
243
244 /**
245 * SACT.Draw (1.0~)
246 * �������ꤵ��Ƥ��륹�ץ饤�Ⱦ��֤���̤�ȿ��(~SP_UPDATE)
247 */
Draw()248 void Draw() {
249 sp_update_all(TRUE);
250
251 DEBUG_COMMAND_YET("SACT.Draw:\n");
252 }
253
254 /**
255 * SCAT.DrawEffect (1.0~)
256 * ���̻����դ����̹���
257 * @param wType: ���ե����ȥ�����
258 * @param wEffectTime: ���ե����Ȥλ���(1/100��ñ��)
259 * @param wEffectKey: ����ȴ������ (1.1~) (1��ͭ��)
260 */
DrawEffect()261 void DrawEffect() {
262 int wType = getCaliValue();
263 int wEffectTime = getCaliValue();
264 int wEffectkey = 1;
265
266 if (sact.version >= 110) {
267 wEffectkey = getCaliValue();
268 }
269
270 sp_eupdate(wType, wEffectTime, wEffectkey);
271
272 DEBUG_COMMAND_YET("SACT.DrawEffect %d,%d,%d:\n", wType, wEffectTime, wEffectkey);
273 }
274
275 /**
276 * SCAT.DrawEffectAlphaMap (1.1~)
277 * ���ޥ����Ĥ����̹���
278 * @param nIndexAlphaMap: �ޥ������ֹ�
279 * @param wEffectTime: ���ե����Ȥλ���(1/100��ñ��)
280 * @param wEffectKey: ����ȴ������
281 */
DrawEffectAlphaMap()282 void DrawEffectAlphaMap() {
283 int nIndexAlphaMap = getCaliValue();
284 int wEffectTime = getCaliValue();
285 int wEffectKey = getCaliValue();
286
287 sp_eupdate_amap(nIndexAlphaMap, wEffectTime, wEffectKey);
288
289 DEBUG_COMMAND_YET("SACT.DrawEffectAlphaMap %d,%d,%d:\n", nIndexAlphaMap, wEffectTime, wEffectKey);
290 }
291
292 /**
293 * SCAT.QuakeScreen (1.0~)
294 * �����ɤ餷
295 * @param wType: 0=�IJ�, 1:��ž
296 * @param wParam1: wType=0�ΤȤ�x�����ο���
297 * wType=1�ΤȤ�����
298 * @param wParam2: wType=0�ΤȤ�y�����ο���
299 * wType=1�ΤȤ���ž��
300 * @param wCount: ����(1/100��)
301 * @param nfKeyEnable: ����ȴ�� (1��ͭ��) (1.1~)
302 */
QuakeScreen()303 void QuakeScreen() {
304 int wType = getCaliValue();
305 int wParam1 = getCaliValue();
306 int wParam2 = getCaliValue();
307 int wCount = getCaliValue();
308 int nfKeyEnable = 1;
309
310 if (sact.version >= 110) {
311 nfKeyEnable = getCaliValue();
312 }
313
314 sp_quake_screen(wType, wParam1, wParam2, wCount, nfKeyEnable);
315
316 DEBUG_COMMAND_YET("SACT.QuakeScreen %d,%d,%d,%d,%d:\n", wType, wParam1, wParam2, wCount, nfKeyEnable);
317 }
318
319 /**
320 * SACT.SetOrigin (1.0~)
321 * ����ɸ�ѹ�
322 * @param wX: �����ˤ���غ�ɸ�ΰ���
323 * @param wY: �����ˤ���ٺ�ɸ�ΰ���
324 */
SetOrigin()325 void SetOrigin() {
326 int wX = getCaliValue();
327 int wY = getCaliValue();
328
329 sact.origin.x = wX;
330 sact.origin.y = wY;
331
332 DEBUG_COMMAND_YET("SACT.SetOrigin %d,%d:\n", wX, wY);
333 }
334
335 /**
336 * SACT.SetShow (1.0~)
337 * ���ץ饤�Ȥ�ɽ�����֤��ѹ�
338 * @param wNum: ��Ƭ�Υ��ץ饤���ֹ�
339 * @param wCount: ɽ������Ŀ�
340 * @param wShow: 0:��ɽ��, 1:ɽ��
341 */
SetShow()342 void SetShow() {
343 int wNum = getCaliValue();
344 int wCount = getCaliValue();
345 int wShow = getCaliValue();
346
347 sp_set_show(wNum, wCount, wShow);
348
349 DEBUG_COMMAND_YET("SACT.SetShow %d,%d,%d:\n", wNum, wCount, wShow);
350 }
351
352 /**
353 * SACT.SetBlendRate (1.1~)
354 * ���ץ饤�Ȥ�ɽ�����֤��ѹ�
355 * @param wNum: ��Ƭ�Υ��ץ饤���ֹ�
356 * @param wCount: ɽ������Ŀ�
357 * @param nBlendRate: �֥���Ψ
358 */
SetBlendRate()359 void SetBlendRate() {
360 int wNum = getCaliValue();
361 int wCount = getCaliValue();
362 int nBlendRate = getCaliValue();
363
364 sp_set_blendrate(wNum, wCount, nBlendRate);
365
366 DEBUG_COMMAND_YET("SACT.SetBlendRate %d,%d,%d:\n", wNum, wCount, nBlendRate);
367 }
368
369 /**
370 * SACT.SetPos (1.0~)
371 * ���ץ饤�Ȥ�ɽ�����֤�����(�ѹ�)
372 * @param wNum: ���ץ饤���ֹ�
373 * @param wX: ɽ���غ�ɸ
374 * @param wY: ɽ���ٺ�ɸ
375 */
SetPos()376 void SetPos() {
377 int wNum = getCaliValue();
378 int wX = getCaliValue();
379 int wY = getCaliValue();
380
381 sp_set_pos(wNum, wX, wY);
382
383 DEBUG_COMMAND_YET("SACT.SetPos %d,%d,%d:\n", wNum, wX, wY);
384 }
385
386 /**
387 * SACT.SetMove (1.0~)
388 * ���ץ饤�Ȥΰ�ư (�����˽������᤹)
389 * @param wNum: ���ץ饤���ֹ�
390 * @param wX: ɽ���غ�ɸ
391 * @param wY: ɽ���ٺ�ɸ
392 */
SetMove()393 void SetMove() {
394 int wNum = getCaliValue();
395 int wX = getCaliValue();
396 int wY = getCaliValue();
397
398 sp_set_move(wNum, wX, wY);
399
400 DEBUG_COMMAND_YET("SACT.SetMove %d,%d,%d:\n", wNum, wX, wY);
401 }
402
403 /**
404 * SACT.SetMoveTime (1.0~)
405 * SetMove�ˤ�륹�ץ饤�Ȱ�ư�λ��֤�����
406 * @param wNum: ���ץ饤���ֹ�
407 * @param wTime: ��ư��λ����ޤǤλ���(1/100��ñ��)
408 */
SetMoveTime()409 void SetMoveTime() {
410 int wNum = getCaliValue();
411 int wTime = getCaliValue();
412
413 sp_set_movetime(wNum, wTime);
414
415 DEBUG_COMMAND_YET("SACT.SetMoveTime %d,%d:\n", wNum, wTime);
416 }
417
418 /**
419 * SACT.SetMoveSpeed (1.0~)
420 * SetMove�ˤ�륹�ץ饤�Ȱ�ư��®�٤�����
421 * @param wNum: ���ץ饤���ֹ�
422 * @param wSpeed: ��ư®��(�ǥե���Ȥ�100%�Ȥ���%����)
423 */
SetMoveSpeed()424 void SetMoveSpeed() {
425 int wNum = getCaliValue();
426 int wSpeed = getCaliValue();
427
428 sp_set_movespeed(wNum, wSpeed);
429
430 DEBUG_COMMAND_YET("SACT.SetMoveSpeed %d,%d:\n", wNum, wSpeed);
431 }
432
433 /**
434 * SACT.SetMoveSpeedCount (1.0~)
435 * ʣ���Υ��ץ饤�Ȥ��Ф��륹�ץ饤�Ȱ�ư��®�٤�����
436 * @param wNum: ��Ƭ���ץ饤���ֹ�
437 * @param wCount: �ϰ�
438 * @param wSpeed: ��ư®��(�ǥե���Ȥ�100%�Ȥ���%����)
439 */
SetMoveSpeedCount()440 void SetMoveSpeedCount() {
441 int wNum = getCaliValue();
442 int wCount = getCaliValue();
443 int wSpeed = getCaliValue();
444 int i;
445
446 for (i = wNum; i < (wNum + wCount); i++) {
447 sp_set_movespeed(i, wSpeed);
448 }
449
450 DEBUG_COMMAND_YET("SACT.SetMoveSpeedCount %d,%d,%d:\n", wNum, wCount, wSpeed);
451 }
452
453 /**
454 * SACT.SetSpriteAnimeTimeInterval (1.1~)
455 * ʣ���Υ��ץ饤�Ȥ��Ф��륢�˥������ץ饤�Ȥδֳ�
456 * @param wNum: ��Ƭ���ץ饤���ֹ�
457 * @param wCount: �ϰ�
458 * @param nTime: �ֳ�
459 */
SetSpriteAnimeTimeInterval()460 void SetSpriteAnimeTimeInterval() {
461 int wNum = getCaliValue();
462 int wCount = getCaliValue();
463 int nTime = getCaliValue();
464 int i;
465
466 for (i = wNum; i < (wNum + wCount); i++) {
467 sp_set_animeinterval(i, nTime);
468 }
469
470 DEBUG_COMMAND_YET("SACT.SetSpriteAnimeTimeInterval %d,%d,%d:\n", wNum, wCount, nTime);
471 }
472
473 /**
474 * SACT.AddZKeyHideSprite (1.0~)
475 * ���������Ԥ���Z�����������줿�Ȥ���ɽ��OFF�ˤʤ륹�ץ饤�Ȥ���Ͽ
476 * @param wNum: ���ץ饤���ֹ�
477 */
AddZKeyHideSprite()478 void AddZKeyHideSprite() {
479 int wNum = getCaliValue();
480
481 sp_add_zkey_hidesprite(wNum);
482
483 DEBUG_COMMAND_YET("SACT.AddZKeyHideSprite %d:\n", wNum);
484 }
485
486 /**
487 * SACT.ClearZKeyHideSprite (1.0~)
488 * AddZKeyHideSprite����Ͽ�������ץ饤���ֹ�����ƥ��ꥢ
489 */
ClearZKeyHideSprite()490 void ClearZKeyHideSprite() {
491 sp_clear_zkey_hidesprite_all();
492
493 DEBUG_COMMAND_YET("SACT.ClearZKeyHideSprite:\n");
494 }
495
496 /**
497 * SACT.SpriteFreeze (1.0~)
498 * ���ץ饤�ȥ����å���wIndex�ξ��֤Ǹ��ꤷ��~KEY 2:�ʤɤ�ȿ�����ʤ�
499 * �褦�ˤ���
500 * @param wNum: ���ץ饤���ֹ�
501 * @param wIndex: ���ꤹ������ֹ�(1-3)
502 */
SpriteFreeze()503 void SpriteFreeze() {
504 int wNum = getCaliValue();
505 int wIndex = getCaliValue();
506
507 sp_freeze_sprite(wNum, wIndex);
508
509 DEBUG_COMMAND_YET("SACT.SpriteFreeze %d,%d:\n", wNum, wIndex);
510 }
511
512 /**
513 * SACT.SpriteThaw (1.0~)
514 * Freeze�������ץ饤�Ⱦ��֤���
515 * @param wNum: ���ץ饤���ֹ�
516 */
SpriteThaw()517 void SpriteThaw() {
518 int wNum = getCaliValue();
519
520 sp_thaw_sprite(wNum);
521
522 DEBUG_COMMAND_YET("SACT.SpriteThaw %d:\n", wNum);
523 }
524
525 /**
526 * SACT.SpriteFreezeCount (1.0~)
527 * ʣ���Υ��ץ饤�Ȥ�Freeze����
528 * @param wNum: ��Ƭ���ץ饤���ֹ�
529 * @param wCount: �ϰ�
530 * @param wIndex: ���ꤹ������ֹ�
531 */
SpriteFreezeCount()532 void SpriteFreezeCount() {
533 int wNum = getCaliValue();
534 int wCount = getCaliValue();
535 int wIndex = getCaliValue();
536 int i;
537
538 for (i = wNum; i < (wNum + wCount); i++) {
539 sp_freeze_sprite(i, wIndex);
540 }
541
542 DEBUG_COMMAND_YET("SACT.SpriteFreezeCount %d,%d,%d:\n", wNum, wCount, wIndex);
543 }
544
545 /**
546 * SACT.SpriteThawCount (1.0~)
547 * ʣ����Freeze���ץ饤�Ⱦ��֤β��
548 * @param wNum: ��Ƭ���ץ饤���ֹ�
549 * @param wCount: �ϰ�
550 */
SpriteThawCount()551 void SpriteThawCount() {
552 int wNum = getCaliValue();
553 int wCount = getCaliValue();
554 int i;
555
556 for (i = wNum; i < (wNum + wCount); i++) {
557 sp_thaw_sprite(i);
558 }
559
560 DEBUG_COMMAND_YET("SACT.SpriteThawCount %d,%d:\n", wNum, wCount);
561 }
562
563 /**
564 * SACT.QuakeSpriteAdd (1.0~)
565 * QuakeSprite���ɤ餹���ץ饤�Ȥ��ɲ�
566 * @param wNum: ���ץ饤���ֹ�
567 */
QuakeSpriteAdd()568 void QuakeSpriteAdd() {
569 int wNum = getCaliValue();
570
571 sp_add_quakesprite(wNum);
572
573 DEBUG_COMMAND_YET("SACT.QuakeSpriteAdd %d:\n", wNum);
574 }
575
576 /**
577 * SACT.QuakeSpriteReset (1.0~)
578 * QuakeSpriteAdd����������Ʋ��
579 */
QuakeSpriteReset()580 void QuakeSpriteReset() {
581 sp_clear_quakesprite_all();
582 DEBUG_COMMAND_YET("SACT.QuakeSpriteReset:\n");
583 }
584
585 /**
586 * SACT.QuakeSprite (1.0~)
587 * QuakeSpriteAdd�����ꤷ�����ץ饤�Ȥ��ɤ餹
588 * @param wType: 0:�IJ�(���ƤΥ��ץ饤�Ȥ�Ʊ���褦���ɤ餹)
589 * 1:�IJ�(���ƤΥ��ץ饤�Ȥ�Х�Х���ɤ餹)
590 * @param wAmplitudeX: ���������
591 * @param wAmplitudeY: ���������
592 * @param wCount: ����(1/100��)
593 * @param nfKeyEnable: (1.1~): ����������뤢��(=1)
594 */
QuakeSprite()595 void QuakeSprite() {
596 int wType = getCaliValue();
597 int wAmplitudeX = getCaliValue();
598 int wAmplitudeY = getCaliValue();
599 int wCount = getCaliValue();
600 int nfKeyEnable = 0;
601
602 if (sact.version >= 110) {
603 nfKeyEnable = getCaliValue();
604 }
605
606 sp_quake_sprite(wType, wAmplitudeX, wAmplitudeY, wCount, nfKeyEnable);
607
608 DEBUG_COMMAND_YET("SACT.QuakeSprite %d,%d,%d,%d:\n", wType, wAmplitudeX, wAmplitudeY, wCount);
609 }
610
611 /**
612 * SACT.QuerySpriteIsExist (1.0~)
613 * ����Υ��ץ饤�Ȥ���Ͽ����Ƥ��뤫�ɤ��������
614 * @param wNum: ���ץ饤���ֹ�
615 * @param var: ��Ͽ���֤��֤��ѿ� 0: ̤��Ͽ, 1:����Ͽ
616 */
QuerySpriteIsExist()617 void QuerySpriteIsExist() {
618 int wNum = getCaliValue();
619 int *var = getCaliVariable();
620
621 sp_query_isexist(wNum, var);
622
623 DEBUG_COMMAND_YET("SACT.QuerySpriteIsExist %d,%p:\n", wNum, var);
624 }
625
626 /**
627 * SACT.QuerySpriteInfo (1.0~)
628 * ���ץ饤�Ȥξ�������
629 * @param wNum: ���ץ饤���ֹ�
630 * @param vType: ���ץ饤�ȥ����ס��ƥ����ȥ��ץ饤�Ȥξ���100
631 * @param vCG1: �ãǣ�(�ʤ����ϣ�)
632 * @param vCG2: �ãǣ�(�ʤ����ϣ�)
633 * @param vCG3: �ãǣ�(�ʤ����ϣ�)
634 */
QuerySpriteInfo()635 void QuerySpriteInfo() {
636 int wNum = getCaliValue();
637 int *vType = getCaliVariable();
638 int *vCG1 = getCaliVariable();
639 int *vCG2 = getCaliVariable();
640 int *vCG3 = getCaliVariable();
641
642 sp_query_info(wNum, vType, vCG1, vCG2, vCG3);
643
644 DEBUG_COMMAND_YET("SACT.QuerySpriteInfo %d,%p,%p,%p,%p:\n", wNum, vType, vCG1, vCG2, vCG3);
645 }
646
647 /**
648 * SACT.QuerySpriteShow (1.0~)
649 * ���ץ饤�Ȥ�ɽ������(SP_SHOW����)�����
650 * @param wNum: ���ץ饤���ֹ�
651 * @param vShow: 0:��ɽ��, 1:ɽ��
652 */
QuerySpriteShow()653 void QuerySpriteShow() {
654 int wNum = getCaliValue();
655 int *vShow = getCaliVariable();
656
657 sp_query_show(wNum, vShow);
658
659 DEBUG_COMMAND_YET("SACT.QuerySpriteShow %d,%p:\n", wNum, vShow);
660 }
661
662 /**
663 * SACT.QuerySpritePos (1.0~)
664 * ���ץ饤�Ȥ�ɽ�����֤μ���
665 * @param wNum: ���ץ饤���ֹ�
666 * @param vX: �غ�ɸ
667 * @param vY: �ٺ�ɸ
668 */
QuerySpritePos()669 void QuerySpritePos() {
670 int wNum = getCaliValue();
671 int *vX = getCaliVariable();
672 int *vY = getCaliVariable();
673
674 sp_query_pos(wNum, vX, vY);
675
676 DEBUG_COMMAND_YET("SACT.QuerySpritePos %d,%p,%p:\n", wNum, vX, vY);
677 }
678
679 /**
680 * SACT.QuerySpriteSize (1.0~)
681 * ���ץ饤�Ȥ��礭���μ���
682 * @param wNum: ���ץ饤���ֹ�
683 * @param vWidth: ���ץ饤�Ȥ���
684 * @param vHeight: ���ץ饤�Ȥι⤵
685 */
QuerySpriteSize()686 void QuerySpriteSize() {
687 int wNum = getCaliValue();
688 int *vWidth = getCaliVariable();
689 int *vHeight = getCaliVariable();
690
691 sp_query_size(wNum, vWidth, vHeight);
692
693 DEBUG_COMMAND_YET("SACT.QuerySpriteSize %d,%p,%p:\n", wNum, vWidth, vHeight);
694 }
695
696 /**
697 * SACT.QueryTextPos (1.2~)
698 * ��å��������ץ饤�Ȥ�ʸ������
699 * @param nMesSpID:
700 * @param pwX:
701 * @param pwY:
702 */
QueryTextPos()703 void QueryTextPos() {
704 int wNum = getCaliValue();
705 int *vX = getCaliVariable();
706 int *vY = getCaliVariable();
707
708 sp_query_textpos(wNum, vX, vY);
709
710 DEBUG_COMMAND_YET("SACT.QueryTextPos %d,%p,%p:\n", wNum, vX, vY);
711 }
712
713 /**
714 * SCAT.CG_Clear (1.0~)
715 * CG_Create�Ǻ�������CG�����ƺ��
716 */
CG_Clear()717 void CG_Clear() {
718 scg_freeall();
719
720 DEBUG_COMMAND_YET("SACT.CG_Clear:\n");
721 }
722
723 /**
724 * SACT.CG_Reset (1.0~)
725 * CG_Create�Ǻ�������CG����
726 * @param wNumCG: �������CG�ֹ�
727 */
CG_Reset()728 void CG_Reset() {
729 int wNumCG = getCaliValue();
730
731 scg_free(wNumCG);
732
733 DEBUG_COMMAND_YET("SACT.CG_Reset %d:\n", wNumCG);
734 }
735
736 /**
737 * SACT.CG_QueryType (1.0~)
738 * CG���(CG������)�����
739 * @param wNumCG: CG�ֹ�
740 * @param vType: CG�μ���, 0: ̤����, 1:�������Ƥ���, 2: CG_SET�Ǻ���
741 * 3: CG_REVERSE�Ǻ���, 4: CG_STRETCH�Ǻ���
742 */
CG_QueryType()743 void CG_QueryType() {
744 int wNumCG = getCaliValue();
745 int *vType = getCaliVariable();
746
747 scg_querytype(wNumCG, vType);
748
749 DEBUG_COMMAND_YET("SACT.CG_QueryType %d,%p:\n", wNumCG, vType);
750 }
751
752 /**
753 * SACT.CG_QuerySize (1.0~)
754 * CG���礭�������
755 * @param wNumCG: CG�ֹ�
756 * @param vWidth: ��
757 * @param vHeight: �⤵
758 */
CG_QuerySize()759 void CG_QuerySize() {
760 int wNumCG = getCaliValue();
761 int *vWidth = getCaliVariable();
762 int *vHeight = getCaliVariable();
763
764 scg_querysize(wNumCG, vWidth, vHeight);
765
766 DEBUG_COMMAND_YET("SACT.CG_QuerySize %d,%p,%p:\n", wNumCG, vWidth, vHeight);
767 }
768
769 /**
770 * SACT.CG_QueryBpp (1.0~)
771 * CG��bpp�����
772 * @param wNumCG: CG�ֹ�
773 * @param vBpp: CG��bpp
774 */
CG_QueryBpp()775 void CG_QueryBpp() {
776 int wNumCG = getCaliValue();
777 int *vBpp = getCaliVariable();
778
779 scg_querybpp(wNumCG, vBpp);
780
781 DEBUG_COMMAND_YET("SACT.CG_QueryBpp %d,%p:\n", wNumCG, vBpp);
782 }
783
784 /**
785 * SACT.CG_ExistAlphaMap (1.0~)
786 * CG�Φ��ޥå�(�ޥ���)������У����ʤ���У�
787 * @param wNumCG: CG�ֹ�
788 * @param vMask: 0/1
789 */
CG_ExistAlphaMap()790 void CG_ExistAlphaMap() {
791 int wNumCG = getCaliValue();
792 int *vMask = getCaliVariable();
793
794 scg_existalphamap(wNumCG, vMask);
795
796 DEBUG_COMMAND_YET("SACT.CG_ExistAlphaMap %d,%p:\n", wNumCG, vMask);
797 }
798
799 /**
800 * SACT.CG_Create (1.0~)
801 * ���ꥵ�����������֥���Ψ�λͳѤ�ɽ������
802 * @param wNumCG: CG�ֹ�
803 * @param wWidth: ��
804 * @param wHeight: �⤵
805 * @param wR: RGB�ͤ���(0-255)
806 * @param wG: RGB�ͤ���(0-255)
807 * @param wB: RGB�ͤ���(0-255)
808 * @param wBlendRate: �֥���Ψ(0-255)
809 */
CG_Create()810 void CG_Create() {
811 int wNumCG = getCaliValue();
812 int wWidth = getCaliValue();
813 int wHeight = getCaliValue();
814 int wR = getCaliValue();
815 int wG = getCaliValue();
816 int wB = getCaliValue();
817 int wBlendRate = getCaliValue();
818
819 scg_create(wNumCG, wWidth, wHeight, wR, wG, wB, wBlendRate);
820
821 DEBUG_COMMAND_YET("SACT.CG_Create %d,%d,%d,%d,%d,%d,%d:\n", wNumCG, wWidth, wHeight, wR, wG, wB, wBlendRate);
822 }
823
824 /**
825 * SACT,CG_CreateReverse (1.0~)
826 * ���ˤʤ�CG��ȿž����CG���������
827 * @param wNumCG: CG�ֹ�
828 * @param wNumSrcCG: ���ԡ��θ��ˤʤ�CG���ֹ�
829 * @param wReverseX: X������ȿž�����å�(0:ȿž���ʤ���1:ȿž����)
830 * @param wReverseY: Y������ȿž�����å�(0:ȿž���ʤ���1:ȿž����)
831 */
CG_CreateReverse()832 void CG_CreateReverse() {
833 int wNumCG = getCaliValue();
834 int wNumSrcCG = getCaliValue();
835 int wReverseX = getCaliValue();
836 int wReverseY = getCaliValue();
837
838 scg_create_reverse(wNumCG, wNumSrcCG, wReverseX, wReverseY);
839
840 DEBUG_COMMAND_YET("SACT.CG_CreateReverse %d,%d,%d,%d:\n", wNumCG, wNumSrcCG, wReverseX, wReverseY);
841 }
842
843 /**
844 * SACT.CG_CreateStretch (1.0~)
845 * ���ˤʤ�CG�����⤷���Ͻ̾�����CG���������
846 * @param wNumCG: CG�ֹ�
847 * @param wWidth: ��������CG����
848 * @param wHeight: ��������CG�ι⤵
849 * @param wNumSrcCG: ���ˤʤ�CG���ֹ�
850 */
CG_CreateStretch()851 void CG_CreateStretch() {
852 int wNumCG = getCaliValue();
853 int wWidth = getCaliValue();
854 int wHeight = getCaliValue();
855 int wNumSrcCG = getCaliValue();
856
857 scg_create_stretch(wNumCG, wWidth, wHeight, wNumSrcCG);
858
859 DEBUG_COMMAND_YET("SACT.CG_CreateStretch %d,%d,%d,%d:\n", wNumCG, wWidth, wHeight, wNumSrcCG);
860 }
861
862 /**
863 * SACT.CG_CreateBlend (1.0~)
864 * �����CG�����ͤ��碌��CG�����
865 * @param wNumDstCG: CG�ֹ�(������)
866 * @param wNumBaseCG: �Ť�碌�Τ�ȤȤʤ�CG
867 * @param wX: �Ť�碌����֤Σغ�ɸ
868 * @param wY: �Ť�碌����֤Σٺ�ɸ
869 * @param wNumBlendCG: ��˽Ť�碌��CG
870 * @param wAlphaMapMode: ���ޥåפκ����⡼��
871 */
CG_CreateBlend()872 void CG_CreateBlend() {
873 int wNumDstCG = getCaliValue();
874 int wNumBaseCG = getCaliValue();
875 int wX = getCaliValue();
876 int wY = getCaliValue();
877 int wNumBlendCG = getCaliValue();
878 int wAlphaMapMode = getCaliValue();
879
880 DEBUG_COMMAND_YET("SACT.CG_CreateBlend %d,%d,%d,%d,%d,%d:\n", wNumDstCG, wNumBaseCG, wX, wY, wNumBlendCG, wAlphaMapMode);
881 scg_create_blend(wNumDstCG, wNumBaseCG, wX, wY, wNumBlendCG, wAlphaMapMode);
882
883 }
884
885 /**
886 * SACT.CG_CreateText (1.0~)
887 * ʸ������CG�����
888 * @param wNumCG: ��������CG�ֹ�
889 * @param wSize: ʸ���ι⤵(pixel)
890 * @param wR: ʸ����R��(0-255)
891 * @param wG: ʸ����G��(0-255)
892 * @param wB: ʸ����B��(0-255)
893 * @param wText: ���褹��ʸ�����ѿ����ֹ�
894 */
CG_CreateText()895 void CG_CreateText() {
896 int wNumCG = getCaliValue();
897 int wSize = getCaliValue();
898 int wR = getCaliValue();
899 int wG = getCaliValue();
900 int wB = getCaliValue();
901 int wText = getCaliValue();
902
903 scg_create_text(wNumCG, wSize, wR, wG, wB, wText);
904
905 DEBUG_COMMAND_YET("SACT.CG_CreateText %d,%d,%d,%d,%d,%d:\n", wNumCG, wSize, wR, wG, wB, wText);
906 }
907
908 /**
909 * SACT.CG_CreateTextNum (1.0~)
910 * ���ͤ��饷���ƥ�ƥ����Ȥ�CG�����
911 * @param wNumCG: ��������CG�ֹ�
912 * @param wSize: ʸ���ι⤵(pixel)
913 * @param wR: ʸ����R��(0-255)
914 * @param wG: ʸ����G��(0-255)
915 * @param wB: ʸ����B��(0-255)
916 * @param wFigs: ���
917 * @param wZeroPadding: ����������ʤ���ʬ�������뤫�ɤ����Υե饰
918 * 0:������ᤷ�ʤ� 1:������᤹��
919 * @param wValue: ���褹����
920 */
CG_CreateTextNum()921 void CG_CreateTextNum() {
922 int wNumCG = getCaliValue();
923 int wSize = getCaliValue();
924 int wR = getCaliValue();
925 int wG = getCaliValue();
926 int wB = getCaliValue();
927 int wFigs = getCaliValue();
928 int wZeroPadding = getCaliValue();
929 int wValue = getCaliValue();
930
931 scg_create_textnum(wNumCG, wSize, wR, wG, wB, wFigs, wZeroPadding, wValue);
932
933 DEBUG_COMMAND_YET("SACT.CG_CreateTextNum %d,%d,%d,%d,%d,%d,%d,%d:\n", wNumCG, wSize, wR, wG, wB, wFigs, wZeroPadding, wValue);
934 }
935
936 /**
937 * SACT.CG_Copy (1.0~)
938 * CG��ʣ��
939 * @param wNumDst: ʣ�����CG�ֹ�
940 * @param wNumSrc: ʣ�̸���CG�ֹ�
941 */
CG_Copy()942 void CG_Copy() {
943 int wNumDst = getCaliValue();
944 int wNumSrc = getCaliValue();
945
946 scg_copy(wNumDst, wNumSrc);
947
948 DEBUG_COMMAND_YET("SACT.CG_Copy %d,%d:\n", wNumDst, wNumSrc);
949 }
950
951 /**
952 * SACT.CG_Cut (1.0~)
953 * ����CG�ΰ������ڤ�̤���CG�����
954 * @param wNumDstCG: CG�ֹ�(������)
955 * @param wNumSrcCG: CG�ֹ�(���åȸ�)
956 * @param wX: ���åȳ��ϣغ�ɸ
957 * @param wY: ���åȳ��ϣٺ�ɸ
958 * @param wWidth: �����
959 * @param wHeight: ���åȹ⤵
960 */
CG_Cut()961 void CG_Cut() {
962 int wNumDstCG = getCaliValue();
963 int wNumSrcCG = getCaliValue();
964 int wX = getCaliValue();
965 int wY = getCaliValue();
966 int wWidth = getCaliValue();
967 int wHeight = getCaliValue();
968
969 scg_cut(wNumDstCG, wNumSrcCG, wX, wY, wWidth, wHeight);
970
971 DEBUG_COMMAND_YET("SACT.CG_Cut %d,%d,%d,%d,%d,%d:\n", wNumDstCG, wNumSrcCG, wX, wY, wWidth, wHeight);
972 }
973
974 /**
975 * SACT.CG_PartCopy (1.0~)
976 * ����CG�ΰ������ڤ�̤���CG�������CG�Υ��������ΤϤ�ȤΤޤޤǡ�
977 * �ޥ����ǡ����Τߤ�������Ƹ��ݤ���Υ��������Ѳ�������
978 * @param wNumDstCG: CG�ֹ�(������)
979 * @param wNumSrcCG: CG�ֹ�(��)
980 * @param wX: ���ϣغ�ɸ
981 * @param wY: ���ϣٺ�ɸ
982 * @param wWidth: �����
983 * @param wHeight: ���åȹ⤵
984 */
CG_PartCopy()985 void CG_PartCopy() {
986 int wNumDstCG = getCaliValue();
987 int wNumSrcCG = getCaliValue();
988 int wX = getCaliValue();
989 int wY = getCaliValue();
990 int wWidth = getCaliValue();
991 int wHeight = getCaliValue();
992
993 scg_partcopy(wNumDstCG, wNumSrcCG, wX, wY, wWidth, wHeight);
994
995 DEBUG_COMMAND_YET("SACT.PartCopy %d,%d,%d,%d,%d,%d:\n", wNumDstCG, wNumSrcCG, wX, wY, wWidth, wHeight);
996 }
997
998 /**
999 * SACT.WiatKeySimple (1.0~)
1000 * �̾省�������Ԥ�
1001 * @param vKey: ���Ϥ��줿����
1002 */
WaitKeySimple()1003 void WaitKeySimple() {
1004 int *vKey = getCaliVariable();
1005
1006 DEBUG_COMMAND_YET("SACT.WaitKeySimple %d:\n", vKey);
1007
1008 // �Ȥꤢ����������
1009 sp_update_all(TRUE);
1010
1011 sact.waittype = KEYWAIT_SIMPLE;
1012 sact.waitkey = -1;
1013
1014 while(sact.waitkey == -1) {
1015 sys_keywait(25, TRUE);
1016 }
1017
1018 sact.waittype = KEYWAIT_NONE;
1019
1020 *vKey = sact.waitkey;
1021
1022 }
1023
1024 /**
1025 * SACT.WaitKeyMessgae (1.0~)
1026 * ��å��������������Ԥ�
1027 * @param wMessageMark1: ���ץ饤���ֹ�1(���˥������ץ饤��)
1028 * @param wMessageMark2: ���ץ饤���ֹ�2(���˥������ץ饤��)
1029 * @param wMessageLength: (1.2~)
1030 */
WaitKeyMessage()1031 void WaitKeyMessage() {
1032 int wMessageMark1 = getCaliValue();
1033 int wMessageMark2 = getCaliValue();
1034 int wMessageLength = 0;
1035
1036 if (sact.version >= 120) {
1037 wMessageLength = getCaliValue();
1038 }
1039
1040 smsg_keywait(wMessageMark1, wMessageMark2, wMessageLength);
1041
1042 DEBUG_COMMAND_YET("SACT.WaitKeyMessage %d,%d,%d:\n", wMessageMark1, wMessageMark2, wMessageLength);
1043 }
1044
1045 /**
1046 * SACT.WaitKeySprite (1.0~)
1047 * ���ץ饤�Ƚ����Ԥ�
1048 * @param vOK: 0�ʤ�б�����å�
1049 * @param vRND: �������Ϸ��
1050 * @param vRsv1: ͽ��
1051 * @param vRsv2: ͽ��
1052 */
WaitKeySprite()1053 void WaitKeySprite() {
1054 int *vOK = getCaliVariable();
1055 int *vRND = getCaliVariable();
1056 int *vRsv1 = getCaliVariable();
1057 int *vRsv2 = getCaliVariable();
1058
1059 DEBUG_COMMAND("SACT.WaitKeySprite %p,%p,%p,%p:\n", vOK, vRND, vRsv1, vRsv2);
1060
1061 sp_keywait(vOK, vRND, vRsv1, vRsv2, NULL, -1);
1062
1063 DEBUG_COMMAND_YET("SACT.WaitKeySprite %d,%d,%d,%d:\n", *vOK, *vRND, *vRsv1, *vRsv2);
1064 }
1065
1066 /**
1067 * SACT.PeekKey (1.2~)
1068 * ?????
1069 * @param nKeyCode:
1070 * @param vResult:
1071 */
PeekKey()1072 void PeekKey() {
1073 int nKeyCode = getCaliValue();
1074 int *vResult = getCaliVariable();
1075
1076 WARNING("NOT IMPLEMENTED\n");
1077 DEBUG_COMMAND_YET("SACT.PeekKey %d,%p:\n", nKeyCode, vResult);
1078 }
1079
1080 /**
1081 * SACT.WaitKeySKipKeyUp (1.0~)
1082 * ʸ�����ꥭ����������äѤʤ��λ���Υ�����ޤ��Ԥ�
1083 */
WaitMsgSkipKeyUp()1084 void WaitMsgSkipKeyUp() {
1085 WARNING("NOT IMPLEMENTED\n");
1086 DEBUG_COMMAND_YET("SACT.WaitMsgSkipKeyUp:\n");
1087 }
1088
1089 /**
1090 * SACT.WaiKeySimpleTimeOut (1.0~)
1091 * �����ॢ���ȤĤ�������������
1092 * @param vRND: ���Ϥ��줿����������
1093 * @param vD03: �����ॢ���Ȥ������=1, ���ʤ����=0
1094 * @param wTime: �����ॢ���Ȼ��� (1/100sec)
1095 */
WaitKeySimpleTimeOut()1096 void WaitKeySimpleTimeOut() {
1097 int *vRND = getCaliVariable();
1098 int *vD03 = getCaliVariable();
1099 int wTime = getCaliValue();
1100
1101 sact.waittype = KEYWAIT_SIMPLE;
1102 sact.waitkey = -1;
1103
1104 sys_keywait(wTime * 10, TRUE);
1105 if (sact.waitkey == -1) {
1106 *vD03 = 1;
1107 *vRND = 0;
1108 } else {
1109 *vD03 = 0;
1110 *vRND = sact.waitkey;
1111 }
1112
1113 sact.waittype = KEYWAIT_NONE;
1114
1115 DEBUG_COMMAND_YET("SACT.WaitKeySimpleTimeOut %p,%p,%d:\n", vRND, vD03, wTime);
1116 }
1117
1118 /**
1119 * SACT.WaiKeySpriteTimeOut (1.0~)
1120 * �����ॢ���ȤĤ����ץ饤�ȥ�����������
1121 * @param vOK: 0 �λ�������å�
1122 * @param vRND: �����å����ץ饤�Ȥ��ֹ�
1123 * @param vD01: ���åȥ��ץ饤�Ȥ��ֹ�
1124 * @param vD02: �ץåȥ��ץ饤�Ȥ��ֹ�
1125 * @param vD03: �����ॢ���Ȥ������=1, ���ʤ����=0
1126 * @param wTime: �����ॢ���Ȼ��� (1/100sec)
1127 */
WaitKeySpriteTimeOut()1128 void WaitKeySpriteTimeOut() {
1129 int *vOK = getCaliVariable();
1130 int *vRND = getCaliVariable();
1131 int *vD01 = getCaliVariable();
1132 int *vD02 = getCaliVariable();
1133 int *vD03 = getCaliVariable();
1134 int wTime = getCaliValue();
1135
1136 sp_keywait(vOK, vRND, vD01, vD02, vD03, wTime);
1137
1138 DEBUG_COMMAND_YET("SACT.WaitKeySpriteTimeOut %p,%p,%p,%p,%p,%d:\n", vOK, vRND, vD01, vD02, vD03, wTime);
1139 }
1140
1141 /**
1142 * SACT.QueryMessageSkip (1.0~)
1143 * ??????
1144 * @param vSkip:
1145 */
QueryMessageSkip()1146 void QueryMessageSkip() {
1147 int *vSkip = getCaliVariable();
1148
1149 *vSkip = get_skipMode() ? 1 : 0;
1150
1151 DEBUG_COMMAND_YET("SACT.QueryMessageSkip %p:\n", vSkip);
1152 }
1153
1154 /**
1155 * SACT.RegistReplaceString (1.0~)
1156 * ��å��������ʸ������֤�����
1157 * @param sstr: �Ѵ���ʸ�����ֹ�
1158 * @param dstr: �Ѵ���ʸ�����ֹ�
1159 */
RegistReplaceString()1160 void RegistReplaceString() {
1161 int sstr = getCaliValue();
1162 int dstr = getCaliValue();
1163
1164 sstr_regist_replace(sstr, dstr);
1165
1166 DEBUG_COMMAND_YET("SACT.RegistReplaceString %d,%d:\n", sstr, dstr);
1167 }
1168
1169 /**
1170 * SACT.MessageOutput (1.0~)
1171 * @param wMessageSpriteNumber: ��å�������ɽ�������å��������ץ饤���ֹ�
1172 * (~MES)
1173 * @param wMessageSize: �ե���Ȥ��礭�� (~MES_SIZE|~MES_SET)
1174 * @param wMessageColorR: ��å������ο�(Red) (~MES_SET|~MES_COLOR)
1175 * @param wMessageColorG: ��å������ο�(Green) (~MES_SET|~MES_COLOR)
1176 * @param wMessageColorB: ��å������ο�(Blue) (~MES_SET|~MES_COLOR)
1177 * @param wMessageFont: ��å������Υե����(0:�����å�, 1:��ī)
1178 * (~MES_FONT)
1179 * @param wMessageSpeed: ��å�������ɽ��®��(0:��������̵��, 1:®��,
1180 * 2:�椯�餤, 3: �٤�) (~MES_SPEED) (msec)
1181 * @param wMessageLineSpace: �Դ֥��ڡ��� (~MES_SPC_Y)
1182 * @param wMessageAlign: �Ԥ��� (1.1~)
1183 * @param vMessageLength: ??? (1.2~)
1184 */
MessageOutput()1185 void MessageOutput() {
1186 int wMessageSpriteNumber = getCaliValue();
1187 int wMessageSize = getCaliValue();
1188 int wMessageColorR = getCaliValue();
1189 int wMessageColorG = getCaliValue();
1190 int wMessageColorB = getCaliValue();
1191 int wMessageFont = getCaliValue();
1192 int wMessageSpeed = getCaliValue();
1193 int wMessageLineSpace = getCaliValue();
1194 int wMessageAlign = 0;
1195 int *vMessageLength = NULL;
1196
1197 if (sact.version >= 110) {
1198 wMessageAlign = getCaliValue();
1199 }
1200 if (sact.version >= 120) {
1201 vMessageLength = getCaliVariable();
1202 }
1203
1204 smsg_out(wMessageSpriteNumber, wMessageSize, wMessageColorR, wMessageColorG, wMessageColorB, wMessageFont, wMessageSpeed, wMessageLineSpace, wMessageAlign, 0, 0, 0, vMessageLength);
1205
1206 DEBUG_COMMAND_YET("SACT.MessageOutput %d,%d,%d,%d,%d,%d,%d,%d,%d,%p:\n", wMessageSpriteNumber, wMessageSize, wMessageColorR, wMessageColorG, wMessageColorB, wMessageFont, wMessageSpeed, wMessageLineSpace, wMessageAlign, vMessageLength);
1207 }
1208
1209 /**
1210 * SACT.MessageOutputEx (1.1~)
1211 * ��ӤĤ���å���������
1212 * @param wMessageSpriteNumber: ��å�������ɽ�������å��������ץ饤���ֹ�
1213 * (~MES)
1214 * @param wMessageSize: �ե���Ȥ��礭�� (~MES_SIZE|~MES_SET)
1215 * @param wMessageColorR: ��å������ο�(Red) (~MES_SET|~MES_COLOR)
1216 * @param wMessageColorG: ��å������ο�(Green) (~MES_SET|~MES_COLOR)
1217 * @param wMessageColorB: ��å������ο�(Blue) (~MES_SET|~MES_COLOR)
1218 * @param wMessageFont: ��å������Υե����(0:�����å�, 1:��ī)
1219 * (~MES_FONT)
1220 * @param wMessageSpeed: ��å�������ɽ��®��(0:��������̵��, 1:®��,
1221 * 2:�椯�餤, 3: �٤�) (~MES_SPEED)
1222 * @param wMessageLineSpace: �Դ֥��ڡ��� (~MES_SPC_Y)
1223 * @param wMessageAlign: �Ԥ���
1224 * @param wRubySize: ���ʸ�����礭��
1225 * @param wRubyFont: ���ʸ���Υե���Ȥμ���((0:�����å�, 1:��ī)
1226 * @param wRubyLineSpace: ���ʸ���ȥ�å������ιԴ֥��ڡ���
1227 * @param vLength: ??? (1.2~)
1228 */
MessageOutputEx()1229 void MessageOutputEx() {
1230 int wMessageSpriteNumber = getCaliValue();
1231 int wMessageSize = getCaliValue();
1232 int wMessageColorR = getCaliValue();
1233 int wMessageColorG = getCaliValue();
1234 int wMessageColorB = getCaliValue();
1235 int wMessageFont = getCaliValue();
1236 int wMessageSpeed = getCaliValue();
1237 int wMessageLineSpace = getCaliValue();
1238 int wMessageAlign = getCaliValue();
1239 int wRubySize = getCaliValue();
1240 int wRubyFont = getCaliValue();
1241 int wRubyLineSpace = getCaliValue();
1242 int *vLength = NULL;
1243
1244 if (sact.version >= 120) {
1245 vLength = getCaliVariable();
1246 }
1247
1248 smsg_out(wMessageSpriteNumber, wMessageSize, wMessageColorR, wMessageColorG, wMessageColorB, wMessageFont, wMessageSpeed, wMessageLineSpace, wMessageAlign, wRubySize, wRubyFont, wRubyLineSpace, vLength);
1249
1250 DEBUG_COMMAND_YET("SACT.MessageOutputEx %d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%p:\n", wMessageSpriteNumber, wMessageSize, wMessageColorR, wMessageColorG, wMessageColorB, wMessageFont, wMessageSpeed, wMessageLineSpace,wMessageAlign, wRubySize, wRubyFont, wRubyLineSpace, vLength);
1251 }
1252
1253 /**
1254 * SACT.MessageNewLine (1.0~)
1255 * ����(�ҥ��ޥ������) (~MES_NEW_LINE)
1256 * @param wMessageSpriteNumber: ��å��������ץ饤���ֹ�
1257 * @param wMessageSize: �ե���Ȥ��礭�� (~MES_SIZE|~MES_SET)
1258 */
MessageNewLine()1259 void MessageNewLine() {
1260 int wMessageSpriteNumber = getCaliValue();
1261 int wMessageSize = getCaliValue();
1262
1263 smsg_newline(wMessageSpriteNumber, wMessageSize);
1264
1265 DEBUG_COMMAND_YET("SACT.MessageNewLine %d,%d:\n", wMessageSpriteNumber, wMessageSize);
1266 }
1267
1268 /**
1269 * SACT.MessageClear (1.0~)
1270 * ��å������ΰ�ξõ�(A���ޥ������)
1271 * @param wMessageSpriteNumber: ��å��������ץ饤���ֹ�
1272 */
MessageClear()1273 void MessageClear() {
1274 int wMessageSpriteNumber = getCaliValue();
1275
1276 smsg_clear(wMessageSpriteNumber);
1277
1278 DEBUG_COMMAND_YET("SACT.MessageClear %d:\n", wMessageSpriteNumber);
1279 }
1280
1281 /**
1282 * SACT.MessageIsEmpty (1.0~)
1283 * ��å��������ĤäƤ����� wResult �� 0 ���֤�?
1284 * @param wResult: ��̤��֤��ѿ�
1285 */
MessageIsEmpty()1286 void MessageIsEmpty() {
1287 int *wResult = getCaliVariable();
1288
1289 *wResult = smsg_is_empty();
1290
1291 DEBUG_COMMAND_YET("SACT.MessageIsEmpty %p:\n", wResult);
1292 }
1293
1294 /**
1295 * SACT.MessagePeek (1.2+~) (�ʤߤ������ˤϤʤ�)
1296 * ��å������Хåե������Ƥ��������
1297 * @param vCount: ���������Կ�
1298 * @param nTopStringNum: �Хåե����������ʸ�����ѿ��κǽ�
1299 */
MessagePeek()1300 void MessagePeek() {
1301 int *vCount = getCaliVariable();
1302 int nTopStringNum = getCaliValue();
1303
1304 WARNING("NOT IMPLEMENTED\n");
1305
1306 DEBUG_COMMAND_YET("SACT.MessagePeek %p,%d:\n", vCount, nTopStringNum);
1307 }
1308
1309 /**
1310 * SACT.Log_Stop (1.2~)
1311 * ������
1312 */
Log_Stop()1313 void Log_Stop() {
1314 sact.logging = FALSE;
1315 DEBUG_COMMAND_YET("SACT.Log_Stop:\n");
1316 }
1317
1318 /**
1319 * SACT.Log_Start (1.2~)
1320 * ���μ賫��
1321 */
Log_Start()1322 void Log_Start() {
1323 sact.logging = TRUE;
1324 DEBUG_COMMAND_YET("SACT.Log_Start:\n");
1325 }
1326
1327 /**
1328 * SACT.MenuClear (1.0~)
1329 * SACT����������������ꥢ
1330 */
MenuClear()1331 void MenuClear() {
1332 ssel_clear();
1333
1334 DEBUG_COMMAND_YET("SACT.MenuClear:\n");
1335 }
1336
1337 /**
1338 * SACT.MenuAdd (1.0~)
1339 * ��Ͽʸ�����SACT��������������ɲ�
1340 * @param nString: ��Ͽ����ʸ�����ѿ��ֹ�
1341 * @param wI: ��Ͽ������� (1-)
1342 */
MenuAdd()1343 void MenuAdd() {
1344 int nString = getCaliValue();
1345 int wI = getCaliValue();
1346
1347 ssel_add(nString, wI);
1348
1349 DEBUG_COMMAND_YET("SACT.MenuAdd %d,%d:\n", nString, wI);
1350 }
1351
1352 /**
1353 * SACT.MenuOpen (1.0~)
1354 * SACT��������롼��
1355 * @param wMenuResult: ������(�ֹ�) ������뤷����0
1356 * @param wNum: ��,�طʤȤ��륹�ץ饤���ֹ� (~SP_SEL)
1357 * @param wChoiceSize: �����ʸ�������� (~SEL_SIZE)
1358 * @param wMenuOutSpc: �ȥ��ץ饤�Ȥγ�¦����Υԥ������(~SP_SETSELSPC)
1359 * @param wChoiceLineSpace: �����ιԴ�(1�˸���?)
1360 * @param wChoiceAutoMoveCursor: �����ץ���˼�ưŪ�˰�ư�����������ֹ�
1361 * @param nAlign: �Ԥ��� (0:��, 1:���, 2: ��) (1.1~)
1362 */
MenuOpen()1363 void MenuOpen() {
1364 int *wMenuResult = getCaliVariable();
1365 int wNum = getCaliValue();
1366 int wChoiceSize = getCaliValue();
1367 int wMenuOutSpc = getCaliValue();
1368 int wChoiceLineSpace = getCaliValue();
1369 int wChoiceAutoMoveCursor = getCaliValue();
1370 int nAlign = 0;
1371
1372 if (sact.version >= 110) {
1373 nAlign = getCaliValue();
1374 }
1375
1376 *wMenuResult = ssel_select(wNum, wChoiceSize, wMenuOutSpc, wChoiceLineSpace, wChoiceAutoMoveCursor, nAlign);
1377
1378 DEBUG_COMMAND_YET("SACT.MenuOpen %p,%d,%d,%d,%d,%d,%d:\n", wMenuResult, wNum, wChoiceSize, wMenuOutSpc, wChoiceLineSpace, wChoiceAutoMoveCursor, nAlign);
1379 }
1380
1381 /**
1382 * SACT.PushString (1.0~)
1383 * SACT������ʸ�����ѿ���ץå���
1384 * @param nString: ʸ�����ѿ��ֹ�
1385 */
PushString()1386 void PushString() {
1387 int nString = getCaliValue();
1388
1389 sstr_push(nString);
1390
1391 DEBUG_COMMAND_YET("SACT.PushString %d:\n", nString);
1392 }
1393
1394 /**
1395 * SACT.PopString (1.0~)
1396 * SACT�����˥ץå��夷��ʸ�����ѿ���ݥå�
1397 * @param nString: ʸ�����ѿ��ֹ�
1398 */
PopString()1399 void PopString() {
1400 int nString = getCaliValue();
1401
1402 sstr_pop(nString);
1403
1404 DEBUG_COMMAND_YET("SACT.PopString %d:\n", nString);
1405 }
1406
1407 /**
1408 * SACT.Numeral_XXXX
1409 * ���ץ饤����ˡ�����ο���(0��9)���Ф����б�����CG�ֹ��
1410 * ɽ�����֡��ֳ֤ʤɤ��Ǽ�����Ф���Ԥ�
1411 */
1412
1413 /**
1414 * SACT.Numeral_SetCG (1.0~)
1415 * ����ο��ͤ��Ф���CG�ֹ������
1416 * @param nNum: ���ץ饤���ֹ�
1417 * @param nIndex: ����(0-9)
1418 * @param nCG: �������б�����CG�ֹ�
1419 */
Numeral_SetCG()1420 void Numeral_SetCG() {
1421 int nNum = getCaliValue();
1422 int nIndex = getCaliValue();
1423 int nCG = getCaliValue();
1424
1425 sp_num_setcg(nNum, nIndex, nCG);
1426
1427 DEBUG_COMMAND_YET("SACT.Numeral_SetCG %d,%d,%d:\n", nNum, nIndex, nCG);
1428 }
1429
1430 /**
1431 * SACT.Numeral_GetCG (1.0~)
1432 * ����ο��ͤ��Ф���CG�ֹ������
1433 * @param nNum: ���ץ饤���ֹ�
1434 * @param nIndex: ����(0-9)
1435 * @param vCG: ���ꤵ��Ƥ���CG�ֹ���֤��ѿ�
1436 */
Numeral_GetCG()1437 void Numeral_GetCG() {
1438 int nNum = getCaliValue();
1439 int nIndex = getCaliValue();
1440 int *vCG = getCaliVariable();
1441
1442 sp_num_getcg(nNum, nIndex, vCG);
1443
1444 DEBUG_COMMAND_YET("SACT.Numeral_GetCG %d,%d,%p:\n", nNum, nIndex, vCG);
1445 }
1446
1447 /**
1448 * SACT.Numeral_SetPos (1.0~)
1449 * Numeral��ɽ�����֤�����
1450 * @param nNum: ���ץ饤���ֹ�
1451 * @param nX: ɽ���غ�ɸ
1452 * @param ny: ɽ���ٺ�ɸ
1453 */
Numeral_SetPos()1454 void Numeral_SetPos() {
1455 int nNum = getCaliValue();
1456 int nX = getCaliValue();
1457 int nY = getCaliValue();
1458
1459 sp_num_setpos(nNum, nX, nY);
1460
1461 DEBUG_COMMAND_YET("SACT.Numeral_SetPos %d,%d,%d:\n", nNum, nX, nY);
1462 }
1463
1464 /**
1465 * SACT.Numeral_GetPos (1.0~)
1466 * Numeral_SetPos�����ꤷ����ɸ�μ��Ф�
1467 * @param nNum: ���ץ饤���ֹ�
1468 * @param vX: �غ�ɸ���Ǽ�����ѿ�
1469 * @param vY: �ٺ�ɸ���Ǽ�����ѿ�
1470 */
Numeral_GetPos()1471 void Numeral_GetPos() {
1472 int nNum = getCaliValue();
1473 int *vX = getCaliVariable();
1474 int *vY = getCaliVariable();
1475
1476 sp_num_getpos(nNum, vX, vY);
1477
1478 DEBUG_COMMAND_YET("SACT.Numeral_GetPos %d,%p,%p:\n", nNum, vX, vY);
1479 }
1480
1481 /**
1482 * SACT.Numeral_SetSpan (1.0~)
1483 * Numeral�δֳ�(Span)������
1484 * @param nNum: ���ץ饤���ֹ�
1485 * @param nSpan: �ֳ�
1486 */
Numeral_SetSpan()1487 void Numeral_SetSpan() {
1488 int nNum = getCaliValue();
1489 int nSpan = getCaliValue();
1490
1491 sp_num_setspan(nNum, nSpan);
1492
1493 DEBUG_COMMAND_YET("SACT.Numeral_SetSpan %d,%d:\n", nNum, nSpan);
1494 }
1495
1496 /**
1497 * SACT.Numeral_GetSpan (1.0~)
1498 * Numeral_SetSpan�����ꤷ���ͤμ��Ф�
1499 * @param nNum: ���ץ饤���ֹ�
1500 * @param vSpan: �ͤ��Ǽ�����ѿ�
1501 */
Numeral_GetSpan()1502 void Numeral_GetSpan() {
1503 int nNum = getCaliValue();
1504 int *vSpan = getCaliVariable();
1505
1506 sp_num_getspan(nNum, vSpan);
1507
1508 DEBUG_COMMAND_YET("SACT.Numeral_GetSpan %d,%p:\n", nNum, vSpan);
1509 }
1510
1511 /**
1512 * SACT.ExpSp_Clear (1.0~)
1513 * �������ץ饤�����ꥯ�ꥢ
1514 */
ExpSp_Clear()1515 void ExpSp_Clear() {
1516 DEBUG_COMMAND_YET("SACT.ExpSp_Clear:\n");
1517
1518 sp_exp_clear();
1519 }
1520
1521 /**
1522 * SACT.ExpSp_Add (1.0~)
1523 * �������ץ饤�������ɲ�
1524 * @param wNumSP1: �����å����ץ饤��
1525 * @param wNumSP2: �������ץ饤��
1526 */
ExpSp_Add()1527 void ExpSp_Add() {
1528 int wNumSP1 = getCaliValue();
1529 int wNumSP2 = getCaliValue();
1530
1531 sp_exp_add(wNumSP1, wNumSP2);
1532
1533 DEBUG_COMMAND_YET("SACT.ExpSp_Add %d,%d:\n", wNumSP1, wNumSP2);
1534 }
1535
1536 /**
1537 * SACT.ExpSp_Del (1.0~)
1538 * �������ץ饤�Ⱥ��
1539 * @param wNum: ���ץ饤���ֹ�
1540 */
ExpSp_Del()1541 void ExpSp_Del() {
1542 int wNum = getCaliValue();
1543
1544 sp_exp_del(wNum);
1545
1546 DEBUG_COMMAND_YET("SACT.ExpSp_Del %d:\n", wNum);
1547 }
1548
1549 /**
1550 * SACT.TimerSet (1.0~)
1551 * �����ID�Υ����ޡ���wCount�ͤǥꥻ�å�
1552 * @param wTimerID: �����ޡ�ID
1553 * @param wCount: �ꥻ�åȤ�����
1554 */
TimerSet()1555 void TimerSet() {
1556 int wTimerID = getCaliValue();
1557 int wCount = getCaliValue();
1558
1559 stimer_reset(wTimerID, wCount);
1560
1561 DEBUG_COMMAND("SACT.TimerSet %d,%d:\n", wTimerID, wCount);
1562 }
1563
1564 /**
1565 * SACT.TimerGet (1.0~)
1566 * �����ID�Υ����ޡ���RND�˼���
1567 * @param wTimerID: �����ޡ�ID
1568 * @param vRND: ���������ѿ�
1569 */
TimerGet()1570 void TimerGet() {
1571 int wTimerID = getCaliValue();
1572 int *vRND = getCaliVariable();
1573
1574 *vRND = stimer_get(wTimerID);
1575
1576 DEBUG_COMMAND("SACT.TimerGet %d,%p:\n", wTimerID, vRND);
1577 }
1578
1579 /**
1580 * SACT.TimerWait (1.0~)
1581 * ����ID�Υ����ޡ������ꥫ����Ȥˤʤ�ޤ��Ԥ�
1582 * @param wTimerID: �����ޡ�ID
1583 * @param wCount: ���ꥫ�����
1584 */
TimerWait()1585 void TimerWait() {
1586 int wTimerID = getCaliValue();
1587 int wCount = getCaliValue();
1588
1589 while(wCount > stimer_get(wTimerID)) {
1590 sys_keywait(10, FALSE);
1591 }
1592
1593 DEBUG_COMMAND("SACT.TimerWait %d,%d:\n", wTimerID, wCount);
1594 }
1595
1596 /**
1597 * SACT.Wait (1.1~)
1598 * ������֡����٤Ƥ�ư������
1599 * @param nCount: ����(1/100��ñ��)
1600 */
Wait()1601 void Wait() {
1602 int wCount = getCaliValue();
1603
1604 sys_keywait(wCount*10, FALSE);
1605
1606 DEBUG_COMMAND_YET("SACT.Wait %d:\n", wCount);
1607 }
1608
1609 /**
1610 * SACT.SoundPlay (1.0~)
1611 * �������ľ�ܺ��� (~SOUND_PLAY)
1612 * @param wNum: ���������ֹ�
1613 */
SoundPlay()1614 void SoundPlay() {
1615 int wNum = getCaliValue();
1616
1617 ssnd_play(wNum);
1618
1619 DEBUG_COMMAND_YET("SACT.SoundPlay %d:\n", wNum);
1620 }
1621
1622 /**
1623 * SACT.SoundStop (1.0~)
1624 * ������ɺ������ (~SOUND_STOP)
1625 * @param wNum: ��ߤ����ֹ�
1626 * @param wFadeTime: ��ߤ���ޤǤλ��� (1/100sec)
1627 */
SoundStop()1628 void SoundStop() {
1629 int wNum = getCaliValue();
1630 int wFadeTime = getCaliValue();
1631
1632 ssnd_stop(wNum, wFadeTime);
1633
1634 DEBUG_COMMAND_YET("SACT.SoundStop %d,%d:\n", wNum, wFadeTime);
1635 }
1636
1637 /**
1638 * SACT.SoundStopAll (1.1~)
1639 * ������ɺ������ (~SOUND_STOP)
1640 * @param wNum: ��ߤ����ֹ�
1641 * @param wFadeTime: ��ߤ���ޤǤλ��� (1/100sec)
1642 */
SoundStopAll()1643 void SoundStopAll() {
1644 int wFadeTime = getCaliValue();
1645
1646 ssnd_stopall(wFadeTime);
1647
1648 DEBUG_COMMAND_YET("SACT.SoundStopAll %d:\n", wFadeTime);
1649 }
1650
1651 /**
1652 * SACT.SoundWait (1.0~)
1653 * �إå��ǻ��ꤵ�줿����or������λ�ޤ��Ԥ� (~SOUND_WAIT)
1654 * @param wNum: �����ֹ�
1655 */
SoundWait()1656 void SoundWait() {
1657 int wNum = getCaliValue();
1658
1659 ssnd_wait(wNum);
1660
1661 DEBUG_COMMAND_YET("SACT.SoundWait %d:\n", wNum);
1662 }
1663
1664 /**
1665 * SACT.SoundWaitKey (1.0~)
1666 * ���ꤵ�줿������ɤ�������λ���뤫���������������ޤ��Ԥ�
1667 * @param wNum: �����ֹ�
1668 * @param vKey: ������륭��
1669 */
SoundWaitKey()1670 void SoundWaitKey() {
1671 int wNum = getCaliValue();
1672 int *vKey = getCaliVariable();
1673
1674 ssnd_waitkey(wNum, vKey);
1675
1676 DEBUG_COMMAND_YET("SACT.SoundWaitKey %d,%p:\n", wNum, vKey);
1677 }
1678
1679 /**
1680 * SACT.SoundPrepare (1.0~)
1681 * �����������(~SOUND_PREPARE)
1682 * @param wNum: ���������ֹ�
1683 */
SoundPrepare()1684 void SoundPrepare() {
1685 int wNum = getCaliValue();
1686
1687 ssnd_prepare(wNum);
1688
1689 DEBUG_COMMAND_YET("SACT.SoundPrepare %d:\n", wNum);
1690 }
1691
1692 /**
1693 * SACT.SoundPrepareLR (1.0~)
1694 * �����ν�������(����ȿž) (~SOUND_PREPARE_LR)
1695 * @param wNum: ���������ֹ�
1696 */
SoundPrepareLR()1697 void SoundPrepareLR() {
1698 int wNum = getCaliValue();
1699
1700 ssnd_prepareLRrev(wNum);
1701
1702 DEBUG_COMMAND_YET("SACT.SoundPrepareLR %d:\n", wNum);
1703 }
1704
1705 /**
1706 * SACT.SoundPlayLR (1.0~)
1707 * ����ȿž���ƺ��� (~SOUND_PLAY_LR)
1708 * @param wNum: ���������ֹ�
1709 */
SoundPlayLR()1710 void SoundPlayLR() {
1711 int wNum = getCaliValue();
1712
1713 ssnd_playLRrev(wNum);
1714
1715 DEBUG_COMMAND_YET("SACT.SoundPlayLR %d:\n", wNum);
1716 }
1717
1718 /**
1719 * SACT.SpriteSound (1.0~)
1720 * �������(���ץ饤�Ȼ���) (~SP_SOUND)
1721 * @param wNumSP: ���ꤹ�륹�ץ饤���ֹ�
1722 * @param nCount: ���ꤹ��Ŀ�
1723 * @param wNumWave1: Sound1
1724 * @param wNumWave2: Sound2
1725 * @param wNumWave3: Sound3
1726 */
SpriteSound()1727 void SpriteSound() {
1728 int wNumSP = getCaliValue();
1729 int nCount = getCaliValue();
1730 int wNumWave1 = getCaliValue();
1731 int wNumWave2 = getCaliValue();
1732 int wNumWave3 = getCaliValue();
1733 int i;
1734
1735 for (i = wNumSP; i < (wNumSP + nCount); i++) {
1736 sp_sound_set(i, wNumWave1, wNumWave2, wNumWave3);
1737 }
1738
1739 DEBUG_COMMAND_YET("SACT.SpriteSound %d,%d,%d,%d,%d:\n", wNumSP, nCount, wNumWave1, wNumWave2, wNumWave3);
1740 }
1741
1742 /**
1743 * SACT.SpriteSoundWait (1.0~)
1744 * SpriteSound�����ꤷ�����٤Ƥβ��κ�����λ�ޤ��Ԥ� (~SP_SOUND_WAIT)
1745 */
SpriteSoundWait()1746 void SpriteSoundWait() {
1747 DEBUG_COMMAND_YET("SACT.SpriteSoundWait:\n");
1748
1749 sp_sound_wait();
1750 }
1751
1752 /**
1753 * SACT.SpriteSoundOB (1.0~)
1754 * �ϰϳ�����å������Ȥ��β� (~SPRITE_SOUND_OB)
1755 * @param wNumWave: ���������ֹ桢���ǥ��ꥢ
1756 */
SpriteSoundOB()1757 void SpriteSoundOB() {
1758 int wNumWave = getCaliValue();
1759
1760 sp_sound_ob(wNumWave);
1761
1762 DEBUG_COMMAND_YET("SACT.SpriteSoundOB %d:\n", wNumWave);
1763 }
1764
1765 /**
1766 * SACT.MusicCheck (1.0~)
1767 * ���ڥǡ��������뤫�ɤ��� (~MUSIC_CHECK)
1768 * @param wNum: �ֹ�
1769 * @param vRND: 0:�ʤ���1:����
1770 */
MusicCheck()1771 void MusicCheck() {
1772 int wNum = getCaliValue();
1773 int *vRND = getCaliVariable();
1774
1775 *vRND = smus_check(wNum);
1776
1777 DEBUG_COMMAND_YET("SACT.MusicCheck %d,%p:\n", wNum, vRND);
1778 }
1779
1780 /**
1781 * SACT.MusicGetLength (1.0~)
1782 * ���ڥǡ�����Ĺ����1/100��ñ�̤Ǽ��� (~MUSIC_GET_LENGTH)
1783 * @param wNum: �����ֹ�
1784 * @param vRND: ��������Ĺ�����Ǽ�����ѿ�
1785 */
MusicGetLength()1786 void MusicGetLength() {
1787 int wNum = getCaliValue();
1788 int *vRND = getCaliVariable();
1789
1790 *vRND = smus_getlength(wNum);
1791
1792 DEBUG_COMMAND_YET("SACT.MusicGetLength %d,%d:\n", wNum, *vRND);
1793 }
1794
1795 /**
1796 * SACT.MusicGetPos (1.0~)
1797 * ���ڥǡ����κ������֤�1/100��ñ�̤Ǽ��� (~MUSIC_GET_POS)
1798 * @param wNum: �����ֹ�
1799 * @param vRND: �����������֤��Ǽ�����ѿ�
1800 */
MusicGetPos()1801 void MusicGetPos() {
1802 int wNum = getCaliValue();
1803 int *vRND = getCaliVariable();
1804
1805 *vRND = smus_getpos(wNum);
1806
1807 DEBUG_COMMAND_YET("SACT.MusicGetPos %d,%d:\n", wNum, *vRND);
1808 }
1809
1810 /**
1811 * SACT.MusicPlay (1.0~)
1812 * ���� (~MUSIC_PLAY)
1813 * @param wNum: �����ֹ�
1814 * @param wFadeTime: �ե����ɥ������(1/100��)
1815 * @param wVolume: ����(0-100)
1816 */
MusicPlay()1817 void MusicPlay() {
1818 int wNum = getCaliValue();
1819 int wFadeTime = getCaliValue();
1820 int wVolume = getCaliValue();
1821
1822 smus_play(wNum, wFadeTime, wVolume);
1823
1824 DEBUG_COMMAND_YET("SACT.MusicPlay %d,%d,%d:\n", wNum, wFadeTime, wVolume);
1825 }
1826
1827 /**
1828 * SACT.MusicStop (1.0~)
1829 * ������� (~MUSIC_STOP)
1830 * @param wNum: �����ֹ�
1831 * @param wFadeTime: ��λ����ޤǤλ���(1/100��)
1832 */
MusicStop()1833 void MusicStop() {
1834 int wNum = getCaliValue();
1835 int wFadeTime = getCaliValue();
1836
1837 smus_stop(wNum, wFadeTime);
1838
1839 DEBUG_COMMAND_YET("SACT.MusicStop %d,%d:\n", wNum, wFadeTime);
1840 }
1841
1842 /**
1843 * SACT.MusicStopAll (1.2~)
1844 * ���٤Ƥβ��ڤ����
1845 * @param wFadeTime: ��λ����ޤǤλ���(1/100��)
1846 */
MusicStopAll()1847 void MusicStopAll() {
1848 int wFadeTime = getCaliValue();
1849
1850 smus_stopall(wFadeTime);
1851
1852 DEBUG_COMMAND_YET("SACT.MusicStopAll %d:\n", wFadeTime);
1853 }
1854
1855 /**
1856 * SACT.MusicFade (1.0~)
1857 * ����Υܥ�塼��ޤǥե����� (~MUSIC_FADE)
1858 * @param wNum: �����ֹ�
1859 * @param wFadeTime: �ե����ɻ���(1/100��)
1860 * @param wVolume: ���� (1-100)
1861 */
MusicFade()1862 void MusicFade() {
1863 int wNum = getCaliValue();
1864 int wFadeTime = getCaliValue();
1865 int wVolume = getCaliValue();
1866
1867 smus_fade(wNum, wFadeTime, wVolume);
1868
1869 DEBUG_COMMAND_YET("SACT.MusicFade %d,%d,%d:\n", wNum, wFadeTime, wVolume);
1870 }
1871
1872 /**
1873 * SACT.MusicWait (1.0~)
1874 * ��������λ����ޤ��Ԥ� (~MUSIC_WAIT)
1875 * @param wNum: �����ֹ�
1876 * @param nTimeOut: (1.1~)
1877 */
MusicWait()1878 void MusicWait() {
1879 int wNum = getCaliValue();
1880 int nTimeOut = 0;
1881
1882 if (sact.version >= 110) {
1883 nTimeOut = getCaliValue();
1884 }
1885
1886 smus_wait(wNum, nTimeOut);
1887
1888 DEBUG_COMMAND_YET("SACT.MusicWait %d,%d:\n", wNum, nTimeOut);
1889 }
1890
1891 /**
1892 * SACT.MusicWatiPos (1.0~)
1893 * ����β��ڤ�wIndex�֤Υޡ����ǻ��ꤵ�줿�������֤����ޤ��Ԥ�
1894 * (~MUSIC_WAIT_POS)
1895 * @param wNum: �����ֹ�
1896 * @param wIndex: ���֥ޡ����ֹ�
1897 */
MusicWaitPos()1898 void MusicWaitPos() {
1899 int wNum = getCaliValue();
1900 int wIndex = getCaliValue();
1901
1902 smus_waitpos(wNum, wIndex);
1903
1904 DEBUG_COMMAND_YET("SACT.MusicWaitPos %d,%d:\n", wNum, wIndex);
1905 }
1906
1907 /**
1908 * SACT.SoundGetLinkNum (1.0~)
1909 * ��������ͥ�Υ���ֹ����� (~SOUND_GET_LINK_NUM)
1910 * @param wNum: �����ͥ��ֹ�
1911 * @param vRND: ����ֹ�(̤���ѡᣰ)
1912 */
SoundGetLinkNum()1913 void SoundGetLinkNum() {
1914 int wNum = getCaliValue();
1915 int *vRND = getCaliVariable();
1916
1917 *vRND = ssnd_getlinknum(wNum);
1918
1919 DEBUG_COMMAND_YET("SACT.SoundGetLinkNum %d,%p:\n", wNum, vRND);
1920 }
1921
1922 /**
1923 * SACT.ChartPos (1.0~)
1924 * ������ѥ��㡼�Ⱥ���
1925 * @param pos : ��̽����ѿ�
1926 * @param pos1: �Ǿ���
1927 * @param pos2: ������
1928 * @param val1: ʬΨ�Ǿ���
1929 * @param val2: ʬΨ������
1930 * @param val : ʬΨ
1931 *
1932 * pos = ((pos2-pos1) / (val2-val1)) * (val-val1) + pos1
1933 */
ChartPos()1934 void ChartPos() {
1935 int *pos = getCaliVariable();
1936 int pos1 = getCaliValue();
1937 int pos2 = getCaliValue();
1938 int val1 = getCaliValue();
1939 int val2 = getCaliValue();
1940 int val = getCaliValue();
1941
1942 schart_pos(pos, pos1, pos2, val1, val2, val);
1943
1944 DEBUG_COMMAND_YET("SACT.ChartPos %p,%d,%d,%d,%d,%d:\n", pos, pos1, pos2, val1, val2, val);
1945 }
1946
1947 /**
1948 * SACT.NumToStr (1.0~)
1949 * ���� -> ʸ�����Ѵ�
1950 * @param strno: �Ѵ��Ѥ�ʸ�����ѿ��ֹ�
1951 * @param fig: ������
1952 * @param zeropad: 0: ������ᤷ�ʤ�, 1: ������᤹��
1953 * @param num: �Ѵ��������
1954 */
NumToStr()1955 void NumToStr() {
1956 int strno = getCaliValue();
1957 int fig = getCaliValue();
1958 int zeropad = getCaliValue();
1959 int num = getCaliValue();
1960
1961 sstr_num2str(strno, fig, zeropad, num);
1962
1963 DEBUG_COMMAND_YET("SACT.NumToStr %d,%d,%d,%d:\n", strno, fig, zeropad, num);
1964 }
1965
1966 /**
1967 * SACT.Maze_Create (1.0~)
1968 */
Maze_Create()1969 void Maze_Create() {
1970 int p1 = getCaliValue();
1971 int p2 = getCaliValue();
1972
1973 WARNING("NOT IMPLEMENTED\n");
1974
1975 DEBUG_COMMAND_YET("SACT.Maze_Create %d,%d:\n", p1,p2);
1976 }
1977
1978 /**
1979 * SACT.Maze_Get (1.0~)
1980 */
Maze_Get()1981 void Maze_Get() {
1982 int *p1 = getCaliVariable();
1983 int p2 = getCaliValue();
1984 int p3 = getCaliValue();
1985
1986 WARNING("NOT IMPLEMENTED\n");
1987
1988 DEBUG_COMMAND_YET("SACT.Maze_Get %p,%d,%d:\n", p1,p2,p3);
1989 }
1990
1991 /**
1992 * SACT.EncryptWORD (1.0~)
1993 */
EncryptWORD()1994 void EncryptWORD() {
1995 int *array = getCaliVariable();
1996 int num = getCaliValue();
1997 int key = getCaliValue();
1998
1999 scryp_encrypt_word(array, num, key);
2000
2001 DEBUG_COMMAND_YET("SACT.EncryptWORD %p,%d,%d:\n", array, num, key);
2002 }
2003
2004 /**
2005 * SACT.DecryptWORD (1.0~)
2006 */
DecryptWORD()2007 void DecryptWORD() {
2008 int *array = getCaliVariable();
2009 int num = getCaliValue();
2010 int key = getCaliValue();
2011
2012 scryp_encrypt_word(array, num, key);
2013
2014 DEBUG_COMMAND_YET("SACT.DecryptWORD %p,%d,%d:\n", array, num, key);
2015 }
2016
2017 /**
2018 * SACT.EncryptString (1.0~)
2019 */
EncryptString()2020 void EncryptString() {
2021 int p1 = getCaliValue();
2022 int p2 = getCaliValue();
2023
2024 scryp_encrypt_str(p1, p2);
2025
2026 DEBUG_COMMAND_YET("SACT.EncryptString %d,%d:\n", p1,p2);
2027 }
2028
2029 /**
2030 * SACT.DecryptString (1.0~)
2031 */
DecryptString()2032 void DecryptString() {
2033 int p1 = getCaliValue();
2034 int p2 = getCaliValue();
2035
2036 scryp_decrypt_str(p1, p2);
2037
2038 DEBUG_COMMAND_YET("SACT.DecryptString %d,%d:\n", p1,p2);
2039 }
2040
2041 /**
2042 * SACT.XMenuClear (1.0~)
2043 * ��ĥ��˥塼�����
2044 */
XMenuClear()2045 void XMenuClear() {
2046 spxm_clear();
2047
2048 DEBUG_COMMAND_YET("SACT.XMenuClear:\n");
2049 }
2050
2051 /**
2052 * SACT.XMenuRegister (1.0~)
2053 * ���ߥХåե��ˤ���ʸ������ĥ��˥塼�Υ����ƥ�Ȥ�����Ͽ
2054 * @param nRegiNum: ��ĥ��˥塼����������ǥå����ֹ�
2055 * @param nMenuID: �����줿�Ȥ����֤��ֹ�(ID)
2056 */
XMenuRegister()2057 void XMenuRegister() {
2058 int nRegiNum = getCaliValue();
2059 int nMenuID = getCaliValue();
2060
2061 spxm_register(nRegiNum, nMenuID);
2062
2063 DEBUG_COMMAND_YET("SACT.XMenuRegister %d,%d:\n", nRegiNum, nMenuID);
2064 }
2065
2066 /**
2067 * SACT.XMenuGetNum (1.0~)
2068 * XMenuRegister����Ͽ���줿ID���֤�
2069 * @param nRegiNum: ��������ǥå����ֹ�
2070 * @param vMenuID: ��Ͽ����Ƥ���ID���Ǽ�����ѿ�
2071 */
XMenuGetNum()2072 void XMenuGetNum() {
2073 int nRegiNum = getCaliValue();
2074 int *vMenuID = getCaliVariable();
2075
2076 *vMenuID = spxm_getnum(nRegiNum);
2077
2078 DEBUG_COMMAND_YET("SACT.XMenuGetNum %d,%p:\n", nRegiNum, vMenuID);
2079 }
2080
2081 /**
2082 * SACT.XMenuGetText (1.0~)
2083 * XMenuRegister����Ͽ���������ƥ������ʸ�����ѿ��˥��ԡ�����
2084 * @param nRegiNum: ��������ǥå����ֹ�
2085 * @param strno: ���ԡ���ʸ�����ѿ��ֹ�
2086 */
XMenuGetText()2087 void XMenuGetText() {
2088 int nRegiNum = getCaliValue();
2089 int strno = getCaliValue();
2090
2091 spxm_gettext(nRegiNum, strno);
2092
2093 DEBUG_COMMAND_YET("SACT.XMenuGetText %d,%d:\n", nRegiNum, strno);
2094 }
2095
2096 /**
2097 * SACT.XMenuTitleRegister (1.0~)
2098 * ���ߥХåե��ˤ���ʸ������ĥ��˥塼�Υ����ȥ�Ȥ�����Ͽ
2099 */
XMenuTitleRegister()2100 void XMenuTitleRegister() {
2101 spxm_titlereg();
2102
2103 DEBUG_COMMAND_YET("SACT.XMenuTitleRegister:\n");
2104 }
2105
2106 /**
2107 * SACT.XMenuTitleGet (1.0~)
2108 * ��ĥ��˥塼�Υ����ȥ������ʸ�����ѿ��˥��ԡ�
2109 * @param strno: ���ԡ���ʸ�����ѿ��ֹ�
2110 */
XMenuTitleGet()2111 void XMenuTitleGet() {
2112 int strno = getCaliValue();
2113
2114 spxm_titleget(strno);
2115
2116 DEBUG_COMMAND_YET("SACT.XMenuTitleGet %d:\n", strno);
2117 }
2118