forked from 247321453/DataEditorX
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy path_function_english
1396 lines (1395 loc) · 89.2 KB
/
_function_english
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#####################################################
# The data types used in the script are the following:
# Int: Integer type
# Bool: Boolean type (true or false)
# String: String
# Function: Function
# Card: The card class
# Effect: The effect class
# Group: The deck class
# Nil: empty type, also said that the empty variables (only that meaningful empty return value)
# Any: any type
# In order to facilitate the description, the use of similar C function representation
# [] Indicates that there are default values that can be omitted
# Indicate only meaningful nil type parameters or return values
#
# Note: Regarding the filter condition function
# The filter condition function is the function whose first argument is of type Card and whose return value is boolean. This function is used to retrieve calls in a filter function that meets the criteria for a deck. The filter condition function can have indefinite parameters, and the second start parameter is obtained from the extra parameters of the filter function. For example:
# Function sample_filter (c, atk, def)
# Return c: GetAttack ()> = atk and c: GetDefense ()> = def
# End
# This function returns true if attack power> = atk and defence> = def for a card c, otherwise false
# G = Duel.GetFieldGroup (0, LOCATION_HAND, 0) - Grab Player 1's Hand Card
# Fg = g: Filter (sample_filter, nil, 1000,500) - Select the attack power> = 1000 from g and the card with> = 500
# Group.Filter only three parameters, the first four parameters start as additional parameters, additional parameters will be passed to the sample_filter
#
# Note: Regarding the specified position
# Some functions can get the specified location of the card, through the three parameters specified int player, int s, int o
# S refers to the player's player's own side of the position, o refers to the player's player for each other's position
# Such as Duel.GetFieldGroup (0, LOCATION_GRAVE, LOCATION_MZONE)
# Return all cards of player 0's cemetery and player's monster zone
#
# Note: For description
# Script system is not directly use the string display prompt text, but by the system through an integer (int desc) to find the appropriate description
# For desc <2048, the system looks for it in string.conf, where some commonly used numbers (usually the prompt text) are recorded in constant.lua
# For desc> 10000, the system looks for a description in the card database, usually specified with the aux.Stringid () function
####################################################
● void initial_effect (Card c)
Called when the card is loaded
General is to register the initial card effect, and set the Soviet students limit and so on
========== bit ===========
● int bit.band (int a, int b)
A and b with the bit
● int bit.lshift (int a, int b)
A Move to the left b
● int bit.bor (int a, int b)
A or b
● int bit.rshift (int a, int b)
A Move to the right b
● int bit.bxor (int a, int b)
A and b bit XOR
========== Card ==========
● int [, int] Card.GetCode (Card c)
Returns the current codename for c (possibly because the effect changes)
● int Card.GetOriginalCode (Card c)
Returns the code number of the card in c
● int, int Card.GetOriginalCodeRule (Card c)
Returns the codename on the c rule (used as a card rule on this card)
● int, int, ... Card.GetFusionCode (Card c)
Return c as the fusion material when the card number (including the original c card number)
● bool Card.IsFusionCode (Card c, int code)
Check the c as a fusion material can be used as the card number for the code card
● bool Card.IsSetCard (Card c, int setname)
Check whether c is a card with the name setname
● bool Card.IsPreviousSetCard (Card c, int setname)
Check whether the name c contains a setname before the c position changes
● bool Card.IsFusionSetCard (Card c, int setname)
Check the c as a fusion material can be used as a name setname card
● int Card.GetType (Card c)
Returns the current type of c
● int Card.GetOriginalType (Card c)
Returns the type of card entry for c
● int Card.GetLevel (Card c)
Returns the current level of c
● int Card.GetRank (Card c)
Returns the current class of c
● int Card.GetSynchroLevel (Card c, Card sc)
Return to the co-ordination of c with the call monster sc with the level
This function returns the same value as Card.GetLevel (c) except for certain cards such as modems.
● int Card.GetRitualLevel (Card c, Card rc)
Returns the ritual liberation level for rc ritual monsters
This function returns the same value as Card.GetLevel (c) except for certain cards such as ritual objects
● int Card.GetOriginalLevel (Card c)
Returns the rank of the card in c
● int Card.GetOriginalRank (Card c)
Returns the class of the card in c
● bool Card.IsXyzLevel (Card c, Card xyzc, int lv)
Check c for excess monster xyzc with the level of whether the excess is lv
● int Card.GetLeftScale (Card c)
Returns the left-hand pendulum scale of c
● int Card.GetOriginalLeftScale (Card c)
Returns the original left-hand pendulum scale of c
● int Card.GetRightScale (Card c)
Returns the right-hand pendulum scale of c
● int Card.GetOriginalRightScale (Card c)
Returns the original right pendulum scale of c
● int Card.GetAttribute (Card c)
Returns the current attribute of c
Note: For some multi-attribute monsters such as light and dark dragon, the return value of this function may be a combination of several properties of the value
● int Card.GetOriginalAttribute (Card c)
Returns the attributes of the card that c is describing
● int Card.GetRace (Card c)
Returns the current race of c
Note: For some multi-ethnic monsters such as animation effects of the magic ape, the function of the return value may be a combination of several racial values
● int Card.GetOriginalRace (Card c)
Returns the c of the card record race
● int Card.GetAttack (Card c)
Return the current attack power of c, the return value is a negative that is "?"
● int Card.GetBaseAttack (Card c)
Return the original attack power of c
● int Card.GetTextAttack (Card c)
Returns the attack power recorded on card c
● int Card.GetDefense (Card c)
Returns the current defense of c, the return value is negative that is "?"
● int Card.GetBaseDefense (Card c)
Return to the original c of the defense
● int Card.GetTextDefense (Card c)
Return the c 's card record of the garrison
● int Card.GetPreviousCodeOnField (Card c)
Returns the card number prior to the c position change
● int Card.GetPreviousTypeOnField (Card c)
Returns the type before the c position change
● int Card.GetPreviousLevelOnField (Card c)
Returns the rank before the c position change
● int Card.GetPreviousRankOnField (Card c)
Returns the class before the c position changes
● int Card.GetPreviousAttributeOnField (Card c)
Returns the attribute before the c position change
● int Card.GetPreviousRaceOnField (Card c)
Returns the race before the c position changes
● int Card.GetPreviousAttackOnField (Card c)
Returns the attack power before the c position changes
● int Card.GetPreviousDefenseOnField (Card c)
Returns the defensive power before the c position changes
● int Card.GetOwner (Card c)
Returns the holder of c
● int Card.GetControler (Card c)
Returns the current controller of c
● int Card.GetPreviousControler (Card c)
Returns the controller before the position change of c
● int Card.GetReason (Card c)
Returns the position change reason for c
● Card Card.GetReasonCard (Card c)
Returns the card that caused the position of c to change
This function is only valid when a card is destroyed by a battle, because the superior call is released, or becomes a special call to use the material
● int Card.GetReasonPlayer (Card c)
Returns the player that caused the position of c to change
● Effect Card.GetReasonEffect (Card c)
Returns the effect that causes the position of c to change
● int Card.GetPosition (Card c)
Returns the current representation of c
● int Card.GetPreviousPosition (Card c)
Returns the representation of the position before the c position changes
● int Card.GetBattlePosition (Card c)
Returns the representation of c before this battle occurs
● int Card.GetLocation (Card c)
Returns the current position of c
● int Card.GetPreviousLocation (Card c)
Returns the position before the c position changes
● int Card.GetSequence (Card c)
Returns the serial number of the current position
In the field, the sequence number on behalf of the grid, from left to right are 0-4, the venue magic number is 5, left and right pendulum area is 6-7
In other places, the serial number represents the first card, the lowest card number is 0
● int Card.GetPreviousSequence (Card c)
Returns the sequence number before the c position changes
● int Card.GetSummonType (Card c)
Returns the call / special call of c
● int Card.GetSummonLocation (Card c)
Returns the call position of c
● int Card.GetSummonPlayer (Card c)
Return to Summoner / Special Summoner c Players
● int Card.GetDestination (Card c)
Returns the destination of the c position change
This function is valid only when processing position transitions instead of effects
● int Card.GetLeaveFieldDest (Card c)
Returns the destination of an effect (such as the universe) that was changed as a result of departure from c
● int Card.GetTurnID (Card c)
Return c The round to the current position
● int Card.GetFieldID (Card c)
Returns the time stamp of the transition to the current position
This value is unique, the smaller the c is the earlier appear in that position
Opening the card from the inside will also change this value
● int Card.GetRealFieldID (Card c)
Returns the actual timestamp for the c transition to the current position
Opening the card from the inside does not change this value
● bool Card.IsCode (Card c, int code1 [, int code2, ...])
Check whether the card number c is code1 [, or code2 ...]
● bool Card.IsType (Card c, int type)
Check if c is of type type
● bool Card.IsRace (Card c, int race)
Check if c is race race
● bool Card.IsAttribute (Card c, int attribute)
Check whether c belongs to attribute attribute
● bool Card.IsReason (Card c, int reason)
Check if c contains the reason
● bool Card.IsStatus (Card c, int status)
Check whether c contains a status code
● bool Card.IsNotTuner (Card c)
Check whether c can be used as a non-adjustment
Void Card.SetStatus (Card c, int state, bool enable)
Set or cancel the status code for c
Do not use this function unless you clearly understand the meaning of each status code
● bool Card.IsDualState (Card c)
Check whether c is in the re-call state
● void Card.EnableDualState (Card c)
Set c to re-call state
Void Card.SetTurnCounter (Card c, int counter)
Set c of the round counter (light of the sword, etc.)
● int Card.GetTurnCounter (Card c)
Returns the round counter for c
● void Card.SetMaterial (Card c, Group g)
The g of all the cards as the c material (superior summon, special summon)
● Group Card.GetMaterial (Card c)
Returns the material used for the appearance of c
● int Card.GetMaterialCount (Card c)
Returns the amount of material used for c appearance
● Group Card.GetEquipGroup (Card c)
Returns the current set of cards
● int Card.GetEquipCount (Card c)
Returns the number of cards currently loaded
● Card Card.GetEquipTarget (Card c)
Returns the current artefact object
● Card Card.GetPreviousEquipTarget (Card c)
Returns the device object before c
● bool Card.CheckEquipTarget (Card c1, Card c2)
Check whether c2 is the correct equipment object for c1
## Determined by the EFFECT_EQUIP_LIMIT effect or confederation state
● int Card.GetUnionCount (Card c)
Returns the number of ally cards for the current device
● Group Card.GetOverlayGroup (Card c)
Returns the currently stacked deck
• int Card.GetOverlayCount (Card c)
Returns the number of cards currently stacked
● Card Card.GetOverlayTarget (Card c)
Returns the card with c as the excess material
● bool Card.CheckRemoveOverlayCard (Card c, int player, int count, int reason)
Check the player player can be reason for the reason, at least remove the c stacked count cards
● bool Card.RemoveOverlayCard (Card c, int player, int min, int max, int reason)
For reason reason, let players player remove c stacked min-max card, the return value that is successful
● Group Card.GetAttackedGroup (Card c)
Returns the card set attacked by this turn
● int Card.GetAttackedGroupCount (Card c)
Returns the number of cards that have been attacked this turn
● int Card.GetAttackedCount (Card c)
Returns the number of times this round has been attacked
Note: If this value is different from the return value of the previous function, then this card has been a direct attack this round
● Group Card.GetBattledGroup (Card c)
Returns the deck of the card that fought this turn
Fighting has occurred in the calculation of the damage occurred, for the sword and other animals, animal judgments
● int Card.GetBattledGroupCount (Card c)
Returns the number of cards battled for this turn
● int Card.GetAttackAncountCount (Card c)
Returns the number of times this declaration was asserted
Note: Attack is invalid will not count the number of attacks, but will be counted into the number of attacks on the Declaration
● bool Card.IsDirectAttacked (Card c)
Check whether c direct attack
Void Card.SetCardTarget (Card c1, Card c2)
C2 as the perpetual object of c1
C1 and c2 of the contact will c1 or c2 any one card to leave or become the side of that reset
● Group Card.GetCardTarget (Card c)
Returns all currently persistent objects
● Card Card.GetFirstCardTarget (Card c)
Returns c the current first persistent object
● int Card.GetCardTargetCount (Card c)
Returns the number of current persistent objects
● bool Card.IsHasCardTarget (Card c1, Card c2)
Check whether c1 takes c2 as a persistent object
● void Card.CancelCardTarget (Card c1, Card c2)
Cancel c2 as a perpetual object of c1
● Group Card.GetOwnerTarget (Card c)
Returns all cards with c as the persistent object
● int Card.GetOwnerTargetCount (Card c)
Returns the number of cards that take c as the persistent object
● Effect Card.GetActivateEffect (Card c)
Returns the effect of the "card firing" of c, that is, the effect of type EFFECT_TYPE_ACTIVATE
Only for magic and traps
● Effect [, Group, int, effect, int, int] Card.CheckActivateEffect (Card c, bool neglect_con, bool neglect_cost, bool copy_info)
Return to the timing of the launch of the correct c "card launch" effect, ignored_con = true ignoring the launch conditions, ignored_cost = true ignoring the launch cost
Copy_info = false or the free-time effect only returns the effect
Otherwise return the effect of the time point for the code when the trigger point information eg, ep, ev, re, r, rp
● int Card.RegisterEffect (Card c, Effect e [, bool forced = false])
Register the effect e to c, return the global id of the effect, and set the Handler of e to c
By default, if c is registered with the effect of immune e then the registration will fail
If forced is true, the immune effect of c against e will not be checked
● bool Card.IsHasEffect (Card c, int code)
Check if c is affected by the effect type
Void Card.ResetEffect (Card c, int reset_code, int reset_type)
To reset the type to reset_type, reset the type reset_code manual reset c impact of the impact
The reset_type can only be one of the following types, and the corresponding reset type is
RESET_EVENT An event reset_code is set for the event
RESET_PHASE End of phase Reset the reset_code to phase
RESET_CODE reset the effect of the specified code reset_code for the type of effect code, can only be reset EFFECT_TYPE_SINGLE sustainable type effect
RESET_COPY resets the effect of the copy. Reset_code is copy_id
RESET_CARD The effect of resetting the card reset_code is the card number of the effect owner
● int Card.GetEffectCount (Card c, int code)
Returns the number of effects that c is affected by the type of code
● Effect Card.RegisterFlagEffect (Card c, int code, int reset_flag, int property, int reset_count [, int label, int desc])
For the registration of a logo with the results
Note: The effect of the registration to the card is not used for the system,
Even if the code and the built-in effect code coincidence will not affect,
And the type is always EFFECT_TYPE_SINGLE, reset method, property, and the general effect of the same,
And will not be invalidated, immune effect from the card
● int Card.GetFlagEffect (Card c, int code)
The type of returned c is the number of identifying effects of the code
Void Card.ResetFlagEffect (Card c, int code)
Manually clear the type of c is the code of the identification effect
● bool Card.SetFlagEffectLabel (Card c, int code, int label)
Returns whether or not c has an identifier of type code, and sets its Label property to label
● int Card.GetFlagEffectLabel (Card c, int code)
The type of c is the label that identifies the effect of code, and returns nil if it does not
● void Card.CreateRelation (Card c1, Card c2, int reset_flag)
For c1 established in c2 contact this contact, only because c1 occurred RESET_EVENT the event reset
● void Card.ReleaseRelation (Card c1, Card c2)
Manually release c1 for c2
● void Card.CreateEffectRelation (Card c, Effect e)
For the card c and the effect of e to establish contact
Void Card.ReleaseEffectRelation (Card c, Effect e)
Manually release the link between c and effect e
● void Card.ClearEffectRelation (Card c)
Clear all the effects of c contact
● bool Card.IsRelateToEffect (Card c, Effect e)
Check whether c is associated with effect e
Note: Each launch into the effect of chain, the effect of launching the card, and the effect of the specified object
(With Duel.SetTargetCard or Duel.SelectTarget specified, including the take and not take objects)
● bool Card.IsRelateToChain (Card c, int chainc)
Check if c is linked to chained chainc
Note: Each launch into the effect of chain, the effect of launching the card, and the effect of the specified object
(With Duel.SetTargetCard or Duel.SelectTarget specified, including the take and not take objects)
Will automatically establish contact with that effect, once the departure, contact will be reset
● bool Card.IsRelateToCard (Card c1, Card c2)
Check whether c1 and c2 are linked
● bool Card.IsRelateToBattle (Card c)
Check whether c is associated with this battle
Note: This effect is usually used for damage calculation before the end of the injury phase, used to check whether the fighting off the card too
● int Card.CopyEffect (Card c, int code, int reset_flag [, int reset_count])
Adding a card number for c is the replicable effect of the card's code, and adding an additional reset condition
The return value is the code id representing the copy effect
● int Card.ReplaceEffect (Card c, int code, int reset_flag [, int reset_count])
Replace the effect of c with the effect of the card whose card number is code, and add additional reset conditions
The return value is the code id representing the replacement effect
● void Card.EnableUnsummonable (Card c)
Set c to a monster that can not normally be called
## is actually a non-replicable, will not be invalid EFFECT_UNSUMMONABLE_CARD effect
● void Card.EnableReviveLimit (Card c)
Add a limit to the cs for c
## Actually is not copyable and will not be affected by invalid EFFECT_UNSUMMONABLE_CARD and EFFECT_REVIVE_LIMIT effects
● void Card.CompleteProcedure (Card c)
So that c to complete the formal call procedures
## This function can also be implemented with Card.SetStatus
● bool Card.IsDisabled (Card c)
Check whether c is in an invalid state
● bool Card.IsDestructable (Card c [, Effect e])
Check whether c is destructible
● bool Card.IsSummonableCard (Card c)
Check whether c is a card that can be called normally
● bool Card.IsSpecialSummonable (Card c)
Check if you can make a special call to c
● bool Card.IsSynchroSummonable (Card c, Card tuner | nil [, Group mg])
Check whether tuner can be used as an adjustment, the field card [or mg] for the coherent material on the c cohomology summon procedures
If the tuner is nil, this function has the same effect as Card.IsSpecialSummonable
● bool Card.IsXyzSummonable (Card c, Group mg | nil [, min = 0, max = 0])
Check whether mg can be selected in the [min-max months] excessive material on the c to call the excess procedure
If mg is nil, this function has the same effect as Card.IsSpecialSummonable
● bool Card.IsSummonable (Card c, bool ignore_count, Effect e | nil [, int min = 0])
Check whether c is usually called (not including the normally called set), ignore_count = true does not check the number of calls limit
E ~ = nil check whether c can be the effect of e is usually called, min said at least the number of sacrifice (used to distinguish between compromise summons and superior call)
● bool Card.IsMSetable (Card, bool ignore_count, Effect e | nil [, int min = 0])
Check whether c can be normally called set, ignore_count = true does not check the number of calls limit
E ~ = nil then check whether c can be the effect of e is usually called set, min that at least the number of sacrifices needed (used to distinguish between compromise summoned set and superior summoned set)
● bool Card.IsSSetable (Card c [, bool ignore_field = false])
Check whether c can be set to the magic trap area, ignore_field = true is disregard of the trap area trap trap
● bool Card.IsCanBeSpecialSummoned (Card c, Effect e, int sumtype, int sumplayer, bool nocheck, bool nolimit [, int sumpos = POS_FACEUP, int target_player = sumplayer])
Check whether c can be sumplayer with the effect of the player e to sumtype form sumpos special summon to target_player field
If nocheck is true, the call condition of c is not checked, and if nolimit is true, then the limit of c is not checked
● bool Card.IsAbleToHand (Card c)
Check whether c can hand
Note: This function returns false only if the card or player is affected by the effect of being unable to join the hand (such as Ray King)
# # The following functions are similar
● bool Card.IsAbleToDeck (Card c)
Check whether c can be sent to the card group
● bool Card.IsAbleToExtra (Card c)
Check if c can send extra cards
This function returns false for non-fusion, cohomology, and overdrive cards
● bool Card.IsAbleToGrave (Card c)
Check whether c can be sent to the cemetery
● bool Card.IsAbleToRemove (Card c [, int player])
Check whether c can be player except player
● bool Card.IsAbleToHandAsCost (Card c)
Check whether c can be sent as the cost of hand cards
Note: This function appends the actual destination of c to Card.IsAbleToHand
This function returns false when c is sent to the other hand (if the retraction loop is applicable, or c is a blend, cohomology, and oversize)
# # The following functions are similar
● bool Card.IsAbleToDeckAsCost (Card c)
Check whether c can be sent to the card as a cost group
● bool Card.IsAbleToExtraAsCost (Card c)
Check whether c can be sent as an additional cost card group
● bool Card.IsAbleToDeckOrExtraAsCost (Card c)
Check whether c can be sent as a cost card group or additional card group (for the new Yu-xia, sword fighting beast fusion call monster detection procedures)
● bool Card.IsAbleToGraveAsCost (Card c)
Check whether c can be sent to the cemetery as a cost
● bool Card.IsAbleToRemoveAsCost (Card c)
Check whether c can be excluded as a cost
● bool Card.IsReleasable (Card c)
Check whether c can be liberated (non-superior call)
● bool Card.IsReleasableByEffect (Card c)
Check whether c can be liberated by the effect
● bool Card.IsDiscardable (Card [, int reason = REASON_COST])
Check whether c can be discarded
Note: This function is only used to detect,
REASON_DISCARD as a reason to hand a card to the tomb and will not lead to that card can not be discarded
● bool Card.IsAttackable (Card c)
Check whether c can attack
● bool Card.IsChainAttackable (Card c [, int ac = 2, bool monsteronly = false])
Check whether c can be a continuous attack, c the number of attacks declared> = ac return false
Note: This function returns false when c has made multiple attacks due to effects such as flashing swords
● bool Card.IsFaceup (Card c)
Check whether c is a surface-side representation
● bool Card.IsAttackPos (Card c)
Check whether c is an attack
● bool Card.IsFacedown (Card c)
Check whether c is the backside representation
● bool Card.IsDefensePos (Card c)
Check whether c is a defensive representation
● bool Card.IsPosition (Card c, int pos)
Check whether c is the representation pos
● bool Card.IsPreviousPosition (Card c, int pos)
Check whether the c position before the change is represented by pos
● bool Card.IsControler (Card c, int controler)
Check whether the current control of c is a controler
● bool Card.IsOnField (Card c)
Check if c is present
Note: This function returns false when the monster summons, reverses the call, and when the summon is successful
● bool Card.IsLocation (Card c, int location)
Check if c is the current location
Note: When the monster summon, reverse call, call special summon before the success,
And location = LOCATION_MZONE, this function returns false
● bool Card.IsPreviousLocation (Card c, int location)
Check if the location before c is location
● bool Card.IsLevelBelow (Card c, int level)
Check whether c is below the level level (at least 1)
● bool Card.IsLevelAbove (Card c, int level)
Check whether c is above level level
● bool Card.IsRankBelow (Card c, int rank)
Check whether c is below the rank rank (at least 1)
● bool Card.IsRankAbove (Card c, int rank)
Check whether c is above the class rank
● bool Card.IsAttackBelow (Card c, int atk)
Check whether c is attack power atk below (at least 0)
● bool Card.IsAttackAbove (Card c, int atk)
Check whether c is more than attack power atk
● bool Card.IsDefenseBelow (Card c, int def)
Check whether c is defensive def below (at least 0)
● bool Card.IsDefenseAbove (Card c, int def)
Check c is defensive def above
● bool Card.IsPublic (Card c)
Check if c is open
● bool Card.IsForbidden (Card c)
Check whether c is in the declaration prohibition state
● bool Card.IsAbleToChangeControler (Card c)
Check whether c can change the control
Note: This function returns false only if the card receives the effect of "Can not change control"
● bool Card.IsControlerCanBeChanged (Card c)
Check whether the control of c can be changed
Note: This function appends the space on the field to the Card.IsAbleToChangeControler
● bool Card.AddCounter (Card c, int countertype, int count [, int singly = false])
Place count count counter type c for c, singly true to add one to the upper limit
Void Card.RemoveCounter (Card c, int player, int countertype, int count, int reason)
Let the player player remove count counters of type c on c with reason
● int Card.GetCounter (Card c, int countertype)
Returns the number of countertype types on c
Void Card.EnableCounterPermit (Card c, int countertype [, int location])
Allow c [to be placed in the location location] that can be placed "can be placed on the counter countertype
The default value of location depends on the type of c, and the monster needs to specify whether it can place a pointer in a monster or pendulum area
Void Card.SetCounterLimit (Card c, int countertype, int count)
Set c to place the upper limit of countertype type counters
● bool Card.IsCanTurnSet (Card c)
Check whether c can turn into the inside of that
● bool Card.IsCanAddCounter (Card c, int countertype, int count [, int singly = false])
Check if c can place count counters of type countertype [singly = true]
● bool Card.IsCanRemoveCounter (Card c, int player, int countertype, int count, int reason)
Check if the player player can remove count counters of type c on c for reason
● bool Card.IsCanBeFusionMaterial (Card c [, Card fc, bool ignore_mon = false])
Check whether c can become a [fusion monster fc] fusion material, ignore_mon = true does not check whether c is a monster
● bool Card.IsCanBeSynchroMaterial (Card c [, Card sc, Card tuner])
Check whether c can become a homophonic homophonic monster sc material
● bool Card.IsCanBeRitualMaterial (Card c [, Card sc])
Check whether c can serve as ritual monsters sc sacrifice
● bool Card.IsCanBeXyzMaterial (Card c, Card sc | nil)
Check whether c can become an excessive monster sc excess material
● bool Card.CheckFusionMaterial (Card c [, Group g, Card gc | nil, int chkf = PLAYER_NONE])
Check if g contains a set of fusion material that c needs [must contain gc]
## Check the Condition function for the effect of EFFECT_FUSION_MATERIAL according to the type of c
● bool Card.CheckFusionSubstitute (Card c, Card fc)
Check whether the c can replace the material description card name of the fusion monster fc
● bool Card.IsImmuneToEffect (Card c, Effect e)
Check whether c immune effect e (that is not affected by the impact of e)
● bool Card.IsCanBeEffectTarget (Card c, Effect e)
Check whether c can be the object of effect e
● bool Card.IsCanBeBattleTarget (Card c1, Card c2)
Check whether c1 can become a target of c2
Void Card.AddMonsterAttribute (Card c, int attribute, int race, int level, int atk, int def)
Add the monster value to the trap card
Note: Values recorded in the database are treated as the original value, and are set to zero here
Void Card.TrapMonsterComplete (Card c, int extra_type)
So trap the trap monster c to occupy a magic trap grid, and add the extra_type monster type
Note: The Trap Monster attribute refers to both the monster and the trap at the same time, and an extra trap that makes a magic trap can not be used
Void Card.CancelToGrave (Card c [, bool cancel = true])
Cancel to send to determine the state tomb, cancel = false to reset the tomb to determine the state
Note: to send the tomb to determine the state refers to the field to start without leaving field magic and traps, the state of these cards
Cards sent to the tomb determine the state can not return cards and cards, and sent to the cemetery at the end of the chain
The purpose of this function is to cancel this state to stay in the field, for the light of the sword and seal the Scarlet Scarlet card
● int, int Card.GetTributeRequirement (Card c)
Returns the minimum and maximum number of sacrifices required to normally call c
● Card Card.GetBattleTarget (Card c)
Returns the card that fought with c
● Group, bool Card.GetAttackableTarget (Card c)
Returns the attackable card set and whether it can attack directly
Void Card.SetHint (Card c, int type, int value)
Set the card prompt for type c to c
Type can only be the following value, the corresponding value type is
CHINT_TURN Turns
CHINT_CARD card id
CHINT_RACE race
CHINT_ATTRIBUTE property
CHINT_NUMBER number
CHINT_DESC Description
● void Card.ReverseInDeck (Card c)
The setting c is indicated in the front of the deck
Void Card.SetUniqueOnField (Card c, int s, int o, int unique_code [, int unique_location = LOCATIOIN_ONFIELD])
Set c to unique_code only in the field [or monster area or magic trap area, determined by the unique_location] can only exist one
S is not 0 will check the uniqueness of their field, o is not 0 check the other field uniqueness
● bool Card.CheckUniqueOnField (Card c, int check_player)
Check the uniqueness of c in the check_player field
Void Card.ResetNegateEffect (Card c [, int code1, ...])
Reset c affected by the effect of cards whose card number is code1, code2 ...
Void Card.AssumeProperty (Card c, int assume_type, int assume_value)
Use the value of assume_type c as assume_value (genome fighter)
Assume_type is the following type
ASSUME_CODE card number
The ASSUME_TYPE type
ASSUME_LEVEL class
ASSUME_RANK class
ASSUME_ATTRIBUTE property
ASSUME_RACE race
ASSUME_ATTACK Attack power
ASSUME_DEFENSE Defense
Void Card.SetSPSummonOnce (Card c, int spsummon_code)
Set c can only be a round of a special call (they reveal, wave dragon)
The same spsummon_code shares 1 number of times
========== Effect ==========
● Effect Effect.CreateEffect (Card c)
Create a new empty effect
And the owner of the effect is c
● Effect Effect.GlobalEffect ()
Create a new global effect
● Effect Effect.Clone (Effect e)
Create a new copy of effect e
● void Effect.Reset (Effect e)
The effect of e reset, reset can not be used after this effect
● int Effect.GetFieldID (Effect e)
Gets the id of the effect e
● void Effect.SetDescription (Effect e, int desc)
Sets the effect description for effect e
Void effect.SetCategory (Effect e, int cate)
Set the Category property
Void effect.SetType (Effect e, int type)
Set the Type property for effect e
Void effect.SetCode (Effect e, int code)
Set the Code property for effect e
Void effect.SetProperty (Effect e, int prop1 [, int prop2])
Set the Property property
● void Effect.SetRange (Effect e, int range)
Set the Range property for effect e
Void effect.SetAbsoluteRange (Effect e, int playerid, int s_range, int o_range)
Set the target range property and set the EFFECT_FLAG_ABSOLUTE_RANGE flag
Playerid! = 0 s_range and o_range invert
Void effect.SetCountLimit (Effect e, int count [, int code = 0])
Set the number of times a round can be launched count (only trigger type effect is valid), the same code (not equal to 0 or 1) share a number of times
The code contains the following values that have special properties
EFFECT_COUNT_CODE_OATH The number of vows
EFFECT_COUNT_CODE_DUEL The number of times in the duel
EFFECT_COUNT_CODE_SINGLE the same card more than the number of public use of the effect (not the same name card)
Void effect.SetReset (Effect e, int reset_flag [, int reset_count = 1])
Set the reset parameter
Void effect.SetLabel (Effect e, int label)
Sets the Label property
Void effect.SetLabelObject (Effect e, Card | Group | Effect labelobject)
Sets the LabelObject property
Void effect.SetHintTiming (Effect e, int s_time [, int o_time = s_time])
Set the prompt point
Void effect.SetCondition (Effect e, function con_func)
Set the Condition property
● void Effect.SetCost (Effect e, function cost_func)
Set the Cost property
Void effect.SetTarget (Effect e, function targ_func)
Set the Target property
● void Effect.SetTargetRange (Effect e, int s_range, int o_range)
Set the Target Range property for effect e
S_range refers to our area of influence
The o_range value affects the partner area
If the EFFECT_FLAG_ABSOLUTE_RANGE flag is specified in the property property,
Then s_range refers to the player 1 affected area, o_range refers to player 2 affected area
If this is a call (cover) / limit call (cover) / special call procedure
(EFFECT_SUMMON_PROC / EFFECT_LIMIT_SUMMON_PROC / EFFECT_SPSUMMON_PROC, etc.)
And the property specifies the EFFECT_FLAG_SPSUM_PARAM flag,
Then s_range that special summoned to the players of the venue,
O_range represents a selectable representation
Void effect.SetValue (Effect e, function | int | bool val)
Set the Value property
● void Effect.SetOperation (Effect e, function op_func)
Set the Operation property
Void effect.SetOwnerPlayer (Effect e [, int player])
Set the OwnerPlayer property to player
● int Effect.GetDescription (Effect e)
Returns the description of the effect
● int Effect.GetCode (Effect e)
Returns the code property
● int Effect.GetType (Effect e)
Returns the Type property
● int, int Effect.GetProperty (Effect e)
Returns the Property property
● int Effect.GetLabel (Effect e)
Returns the Label property
● Card | Group | Effect Effect.GetLabelObject (Effect e)
Returns the LabelObject property
● int Effect.GetCategory (Effect e)
Returns the Category property
● Card Effect.GetOwner (Effect e)
Returns the Owner property
● Card Effect.GetHandler (Effect e)
Returns the card on which the effect takes effect (usually a card that registers the effect with Card.RegisterEffect)
● function Effect.GetCondition (Effect e)
Returns the condition property
● function Effect.GetTarget (Effect e)
Returns the target attribute
● function Effect.GetCost (Effect e)
Returns the cost attribute
● function | int Effect.GetValue (Effect e)
Returns the value attribute
● function Effect.GetOperation (Effect e)
Returns the operation attribute
● int Effect.GetActiveType (Effect e)
Returns the effect type of e (monster, magic, trap)
And launch the effect of the type of card is not necessarily the same, such as the spirit of pendulum effect as a magic card effect
● bool Effect.IsActiveType (Effect e, int type)
Check if the effect type of e (monster, magic, trap) has a type
● int Effect.GetOwnerPlayer (Effect e)
Returns the OwnerPlayer property, which is typically the controller of the Owner
● int Effect.GetHandlerPlayer (Effect e)
Return to the current, usually Handle controller
● bool Effect.IsHasProperty (Effect e, int prop1 [, int prop2])
Check if the effect contains the flags prop1 [and prop2]
● bool Effect.IsHasCategory (Effect e, int cate)
Check whether the effect contains cate
● bool Effect.IsHasType (Effect e, int type)
Check if the effect is of type type
● bool Effect.IsActivatable (Effect e, int player)
Check whether the effect can be launched by the player
● bool Effect.IsActivated (Effect e)
Check the effect of e is the effect of starting (chassis)
● int Effect.GetActivateLocation (Effect e)
Returns the firing area of the effect e
========== Group ==========
● Group Group.CreateGroup ()
Create a new empty deck
● void Group.KeepAlive (Group g)
Let the deck continue, set the deck to effect LabelObject needs to be set
● void Group.DeleteGroup (Group g)
Delete the card group g
● Group Group.Clone (Group g)
Create a new copy of card group g
● Group Group.FromCards (Card c [, ...])
Indefinite parameters, the incoming card into a combination of all cards and return
● void Group.Clear (Group g)
Empty the deck
● void Group.AddCard (Group g, Card c)
Increase g to g
● void Group.RemoveCard (Group g, Card c)
Remove c from g
● Card Group.GetFirst (Group g)
Returns the first card in g and resets the current pointer to the first card in g
Returns nil if card does not exist in g
● Card Group.GetNext (Group g)
Point the pointer to the next card and return the card, or nil if it does not exist
● int Group.GetCount (Group g)
Returns the number of cards in g
● void Group.ForEach (Group g, function f)
Call f once for each card in g as a parameter
● Group Group.Filter (Group g, function f, Card ex | nil, ...)
The filter function filters the card from g that satisfies the filter condition f and is not equal to ex
Starting from the 4th parameter as an additional parameter
● int Group.FilterCount (Group g, function f, Card ex | nil, ...)
Filter function, and Group.Filter is basically the same, the difference is that this function only returns the number of cards to meet the conditions
● Group Group.FilterSelect (Group g, int player, function f, int min, int max, Card ex | nil, ...)
Filter function, allowing players to choose from the g player min-max sheets meet the screening conditions f and not equal to the ex card
Starting with the 7th argument is an additional parameter
● Group Group.Select (Group g, int player, int min, int max, Card ex | nil)
Let player player from g select the min-max Zhang is not equal to the ex card
● Group Group.RandomSelect (Group g, int player, int count)
Let the player player randomly select count cards from g
Because it is a random choice, so the basic parameter useless player, randomly selected by the system
● bool Group.IsExists (Group g, function f, int count, Card ex | nil, ...)
Filter function to check if there is at least count of cards in g that satisfy the filter condition f and not equal to ex
Starting from the 5th parameter as an additional parameter
● bool Group.CheckWithSumEqual (Group g, function f, int sum, int min, int max, ...)
The subset summation decision function, f, is a function that returns an interger value
Check whether there is a subset of min-max in g that satisfies that the sum of the values of each element of the subset f is equal to sum, starting at the 6th argument as an extra parameter
For example: g: CheckWithSumEqual (Card.GetSynchroLevel, 7,2,99)
Check if the sum of the same call levels in a subset of g satisfies a subset equal to 7
● Group Group.SelectWithSumEqual (Group g, int player, function f, int sum, int min, int max, ...)
Let the player player select a subset of min-max from g so that the sum of the specific functions of the subset is equal to sum, starting at the 7th argument as an extra parameter
● bool Group.CheckWithSumGreater (Group g, function f, int sum, ...)
The sum of the subsets is determined by a function f, which is a function that returns an interger value
Check that there is a subset in g that satisfies that the sum of the values of each element of the subset f is just greater than or equal to sum, starting at the fourth argument as an extra parameter
For example: g: CheckWithSumGreater (Card.GetRitualLevel, 8)
Check if the sum of the ritual classes in g satisfies a subset of 8 or greater
Note: The decision must be "just" greater than or equal to
To grade, for example, to make the total level is greater than or equal to 8, you can choose LV1 + LV7 and can not choose LV1 + LV4 + LV4
● Group Group.SelectWithSumGreater (Group g, int player, function f, int sum, ...)
Let the player player select a subset from g so that the sum of the particular function f of the subset is greater than or equal to sum, starting at the fifth argument as an extra parameter
● Group, int Group.GetMinGroup (Group g, function f, ...)
F is a function that returns an interger value, and the card with the smallest value of f is selected from g
The second return value is the minimum value, starting at the third parameter as an additional parameter
To use the second return value Note Check g is not empty
● Group, int Group.GetMaxGroup (Group g, function f, ...)
F is the function that returns an interger value, and the card with the largest value of f is selected from g
The second return value is the maximum value, starting with the third parameter as an additional parameter
To use the second return value Note Check g is not empty
● int Group.GetSum (Group g, function f, ...)
Calculates the sum of the values of all cards in g, f is the value function for each card, starting with the third parameter as an additional parameter
● int Group.GetClassCount (Group g, function f, ...)
Calculate the number of all cards in g, f is the basis of the classification, return the same value as the same category, starting from the first three parameters for additional parameters
● void Group.Remove (Group g, function f, Card ex | nil, ...)
Remove all cards from g that satisfy the filter condition f and not equal to ex, the fourth parameter starts with the extra argument
● void Group.Merge (Group g1, Group g2)
Combine all cards in g2 to g1
Note: g2 itself does not change
● void Group.Sub (Group g1, Group g2)
Remove the card from g1 that belongs to g2
Note: g2 itself does not change
● bool Group.Equal (Group g1, Group g2)
It is judged whether or not g1 and g2 are the same
● bool Group.IsContains (Group g, Card c)
Check g for card c
● Card Group.SearchCard (Group g, function f, ...)
Returns the first card in g that satisfies the filter condition f, starting at the third argument as an extra argument
========== Duel ==========
● void Duel.EnableGlobalFlag (int global_flag)
Set the global flag global_flag
● int Duel.GetLP (int player)
Returns the current LP of the player's player
● void Duel.SetLP (int player, int lp)
Set the player's current LP to lp
● int Duel.GetTurnPlayer ()
Returns the current round of players
● int Duel.GetTurnCount ()
Returns the current number of turns
● int Duel.GetDrawCount (int player)
Returns the player's number of rules drawn per turn
● void Duel.RegisterEffect (Effect e, int player)
Register the effect e as the player's effect to the global environment
● Effect Duel.RegisterFlagEffect (int player, int code, int reset_flag, int property, int reset_count)
For the player to register the global environment logo effect
This effect always affects the player's (EFFECT_FLAG_PLAYER_TARGET) and will not be invalidated
The rest is the same as Card.RegisterFlagEffect
● int Duel.GetFlagEffect (int player, int code)
Returns the number of specific marker effects for the player's player
● void Duel.ResetFlagEffect (int player, int code)
Manually reset the player player's specific logo effect
● int Duel.Destroy (Card | Group targets, int reason [, int dest = LOCATION_GRAVE])
Destroy targets dest by reason reason, the return value is actually destroyed by the number
If the reason contains REASON_RULE, the break event will not check whether the card is immune,
Does not trigger the generation of breaking effect and ignore the "can not destroy"
● int Duel.Remove (Card | Group targets, int pos, int reason)
In the case of reason, except for the pos form, the return value is the actual number being manipulated
If the reason contains REASON_TEMPORARY, then the exception is considered temporary, you can return to the field by Duel.ReturnToField
● int Duel.SendtoGrave (Card | Group targets, int reason)
The reason for the targets to the cemetery, the return value is the actual number of operations
Int Duel.SendtoHand (Card | Group targets, int player | nil, int reason)
The reason to target the player sent to the player's hand, the return value is the actual number of operations
If player is nil, the card's holder's hand is returned
Int Duel.SendtoDeck (Card | Group targets, int player | nil, int seq, int reason)
The reason for the targets sent to the players player card group, the return value is the actual number of operations
If player is nil, the card holder of the card is returned
If seq = 0, it is the top of the returned card group; seq = 1 is the bottom of the returned card group;
The rest of the case is to return to the top and mark the need to wash the card group
Int Duel.SendtoExtraP (Card | Group targets, int player | nil, int reason)
The reason for the reason the spirit of the swing card targets sent to the player player extra card group, the return value is the actual number of operations
If player is nil, it returns the extra card group for the card holder
● Group Duel.GetOperatedGroup ()
This function returns a card set that was actually manipulated before a card operation
Duel. Destroy, Duel.Remove, Duel.SendtoGrave,
Duel.SendtoHand, Duel.SendtoDeck, Duel.SendtoExtraP, Duel.Release,
Duel.ChangePosition, Duel.SpecialSummon, Duel.DiscardDeck
● void Duel.Summon (int player, Card c, bool ignore_count, Effect e | nil [, min = 0])
Let the player to the effect of e to c is usually called (not set), at least use min sacrifice
If e = nil, then in accordance with the general rules of the general call usually call
If ignore_count = true, the usual number of calls per turn limit is ignored
● void Duel.SpecialSummonRule (int player, Card c)
Let player player on c special summon procedures
● void Duel.SynchroSummon (int player, Card c, Card tuner [, Group mg])
Let the player player to tuner as the adjustment [mg for the material] on the c cohomology summon procedures
● void Duel.XyzSummon (int player, Card c, Group mg | nil [, min = 0, max = 0])
Let the player player [from the mg] [choose min-max a material] on the c to call the excess procedure
Mg is not empty and min is 0 mg directly to all the excess material
Void void Duel.MSet (int player, Card c, bool ignore_count, Effect e | nil [, min = 0])
Let the player to the effect of c is usually called Set, at least use min sacrifice
If e = nil, then in accordance with the general rules of the general call usually call
If ignore_count = true, the usual number of calls per turn limit is ignored
● void | int Duel.SSet (int player, Card | Group targets [, int target_player = player])
Let the player player place the targets into the target trap's magic trap
If targets is Group, the number of successful operations is returned
● Card Duel.CreateToken (int player, int code [, int setcode, int attack, inte defense, int level, int race, int attribute])
Creates a new Token with the passed in parameter value and returns
Int Duel.SpecialSummon (Card | Group targets, int sumtype, int sumplayer, int target_player, bool nocheck, bool nolimit, int pos)
Let player player to sumtype way, pos that special targets to target_player target field
If nocheck is true, the card's calling condition is disregarded. If nolimit is true,
The return value is the number of cards that were successfully summoned
● bool Duel.SpecialSummonStep (Card c, int sumtype, int sumplayer, int target_player, bool nocheck, bool nolimit, int pos)
This function is Duel.SpecialSummon decomposition process, only a special summon a card c
This function is used for an effect while simultaneously calling multiple cards with different parameters
This function must be used with Duel.SpecialSummonComplete
The return value indicates whether or not the special call succeeded
● void | int Duel.SpecialSummonComplete ()
This function is called after determining that a number of calls to Duel.SpecialSummonStep are completed, for triggering an event
● bool Duel.IsCanAddCounter (int player, int countertype, int count, Card c)
Check if the player can add count counterstype to card c
● bool Duel.RemoveCounter (int player, int s, int o, int countertype, int count, int reason)
Causes the player player to remove count objects of the countertype type present on the farm for reason reasons. The return value indicates success
S represents the position of the player's own removable pointer, o represents the position of the opponent's removable pointer for the player
● bool Duel.IsCanRemoveCounter (int player, int s, int o, int countertype, int count, int reason)
Checks whether the player player can remove count objects of the countertype type on the farm for reason reasons
S represents the position of the player's own removable pointer, o represents the position of the opponent's removable pointer for the player
Int Duel.GetCounter (int player, int s, int o, int countertype)
Returns the number of counterstype types that exist on the farm
S represents the position of the player's own removable pointer, o represents the position of the opponent's removable pointer for the player
Int Duel.ChangePosition (Card | Group targets, int au [, int ad = au, int du = au, int dd = au, bool noflip = false, bool setavailable = false])
Changing the representation of targets returns the number of actual operations
The attack on the watch side becomes au, the attack on the inside indicates ad,
The side of the garage that becomes du, inside the garrison said to become dd
If noflip = true, the reverse effect will not be triggered (but the effect of inversion will be triggered)
If setavailable = true then the object will become the back side also launched reversal effect
● int Duel.Release (Card | Group targets, int reason)
The reason for the liberation of targets to return the value of the actual liberation of the number of targets
If the reason contains REASON_COST, it will not check whether the card is not affected by the effect
● bool Duel.MoveToField (Card c, int move_player, int target_player, int dest, int pos, bool enabled)
Let the player move_player to move the c target_player field, the return value that is successful
Dest can only be LOCATION_MZONE or LOCATION_SZONE, pos represents an optional representation, and enable indicates whether or not the effect of c is applied immediately
● bool Duel.ReturnToField (Card c [, int pos])
To return the form c to the field pos, pos default value is the expression before leaving the field, the return value indicates whether the success
C must be a REASON_TEMPORARY reason to leave, and leave the position did not leave that position
● void Duel.MoveSequence (Card c, int seq)
Move the serial number of c, usually used to change the grid in the field or in the card group to move to the top or bottom
● void Duel.SetChainLimit (function f)
Set the chain conditions, f function prototype for bool f (e, ep, tp)
E said to limit the effect of chain, ep said to limit the chain of players, tp that launched the effect of the players
Calling this function in cost or target processing can limit the kinds of effects that can be chained (such as superfusion)
If f returns false, it means that the chain can not be chained. Once the chain condition has been set, the new chain will be canceled.
● void Duel.SetChainLimitTillChainEnd (function f)
Function with Duel.SetChainLimit, but this function sets the chain until the end of the chain will be lifted
● Effect Duel.GetChainMaterial (int player)
Returns the effect of the chained material that is played by the player. This function is only used to blend the effect of a class card
● void Duel.ConfirmDecktop (int player, int count)
Confirm the player card group above count cards
● void Duel.ConfirmCards (int player, Card | Group targets)
Identify targets for the player
● void Duel.SortDecktop (int sort_player, int target_player, int count)
Let the player sort_player on the player target_player card group at the top count card sort
● bool [, Group, int, int, Effect, int, int] Duel.CheckEvent (int event [, bool get_info])
Check whether the current event point
If get_info = true and is the correct time point also returns the trigger point information eg, ep, ev, re, r, rp
● void Duel.RaiseEvent (Group | Card eg, int code, Effect re, int r, int rp, int ep, int ev)
To eg, ep, ev, re, r, rp trigger a point in time
● void Duel.RaiseSingleEvent (Card ec, int code, Effect re, int r, int rp, int ep, int ev)
To eg, ep, ev, re, r, rp for the card ec trigger a single point in time
● bool Duel.CheckTiming (int timing)
Check whether the current prompt is the timing point
● int, int Duel.GetEnvironment ()
Returns the two values that represent the current venue code, as well as the source of the current venue effect
The site code refers to the code of the venue card in effect, or the value of the effect of the venue change
Source Player is the controller of the card in effect, or the controller of the Poseidon Witch, etc.
● bool Duel.IsEnvironment (int code [, int player = PLAYER_ALL])
Check whether the player player is the source code of the venue code
The site code refers to the code of the venue card in effect, or the value of the effect of the venue change
Source Player is the controller of the card in effect, or the controller of the Poseidon Witch, etc.
● void Duel.Win (int player, int win_reason)
The current effect is dealt with so players win_reason duel victory
● int Duel.Draw (int player, int count, int reason)
Let the player play the count card with the reason, and return the number of cards actually drawn
If the reason contains REASON_RULE the draw is not affected by the "can not draw" effect
● int Duel.Damage (int player, int value, int reason [, bool is_step = false])
To the reason reason to give players the player caused value damage, the actual value of the damage received
The return value is 0 if the damage becomes an effect such as a reply.
Is_step to true is the damage / recovery LP process decomposition, need to call Duel.RDComplete () trigger point
Int Duel.Recover (int player, int value, int reason [, bool is_step = false])
To reason reason players to player value LP, return to the actual response value
The return value is 0 if it is affected by an effect such as a return to harm.
Is_step to true is the damage / recovery LP process decomposition, need to call Duel.RDComplete () trigger point
● void Duel.RDComplete ()
In the call Duel.Damage / Duel.Recover, if is_step parameter is true, you need to call this function when the trigger point
● bool Duel.Equip (int player, Card c1, Card c2 [, bool up = true, bool is_step = false])
The player as a player c1 equipment card equipment to the c2, the return value that is successful
Up = false to retain the card before the representation
Is_step = true is the decomposition of the equipment process, the need to cooperate with Duel.EquipComplete use
● void Duel.EquipComplete ()
In the call Duel.Equip, if is_step parameter is true, you need to call this function when the trigger point
● bool Duel.GetControl (Card | Group targets, int player [, int reset_phase = 0, int reset_count = 0])
Let players get control of the player, the return value indicates success
● bool Duel.SwapControl (Card c1, Card c2 [, int reset_phase = 0, int reset_count = 0])
Exchange c1 and c2 control, the return value that is successful
● bool Duel.CheckLPCost (int player, int cost)
Check player player can pay cost point lp
• void Duel.PayLPCost (int player, int cost)
Allow players to pay cost point player lp
● int Duel.DiscardDeck (int player, int count, int reason)
To reason player player card group top count cards sent to the cemetery, the actual transfer of the number
Int Duel.DiscardHand (int player, function f, int min, int max, int reason, Card ex | nil, ...)
Filter function allows the player to select and discard the player to meet the screening conditions f soldiers is not equal to ex min-max Zhang card
The seventh argument starts as an extra parameter
● void Duel.DisableShuffleCheck ([disable = true])
So that the next operation does not check for the need for a wash card set or a hand card
Note: If you do not call this function,
In addition to calling Duel.DiscardDeck and Duel.Draw remove the card from the card group or add the card to the card
Or the card is added to the deck (not the top or bottom), the system automatically cleans the card group or the hand card at the end of the effect process
If you do not want to do so, for example, from the top of the card group, except for a card and other operations, you need to call this function
This function only ensures that no subsequent scrub detection is performed in the next operation
● void Duel.ShuffleDeck (int player)
Manually cleans the player group
NOTE: The status of the wash detection is reset
● void Duel.ShuffleHand (int player)
Manual wash player player's hand card
NOTE: The status of the wash detection is reset
● void Duel.ShuffleSetCard (Group g)
Cut the card (magic hat) over the monster area
● void Duel.ChangeAttacker (Card c)
Will attack the monster into c
Note: This function will make the original attack monster attack
# ● void Duel.ReplaceAttacker (Card c)
# Use c to replace the currently attacked card for the damage phase
● bool Duel.ChangeAttackTarget (Card c | nil)
Will attack the object into c, c for nil that direct attack, the return value indicates whether the successful transfer of attack objects
● void Duel.ReplaceAttackTarget (Card c)
(Reserved)
● void Duel.CalculateDamage (Card c1, Card c2)
Let c1 and c2 combat damage calculation
● int Duel.GetBattleDamage (int player)
Returns the player's player's damage during this battle
● void Duel.ChangeBattleDamage (int player, int value [, bool check = true])
The player player in this battle by the harm into value, check for false is the original combat damage to 0 also change the damage
● void Duel.ChangeTargetCard (int chainc, Group g)
The chain chainc the object into g
● void Duel.ChangeTargetPlayer (int chainc, in player)
The chain chainc the object player into player
● void Duel.ChangeTargetParam (int chainc, int param)
The chain chainc parameters into param
● void Duel.BreakEffect ()
Interrupt the current effect, so that after the effect of treatment as not treated simultaneously, this function will cause the wrong time
● void Duel.ChangeChainOperation (int chainc, function f)
The effect of the chain chainc processing function replaced by f, used to achieve "the effect becomes" effect
● bool Duel.NegateActivation (int chainc)
So that the chain chainc launch invalid, the return value that is successful
● bool Duel.NegateEffect (int chainc)
So that the chain chainc invalid effect, the return value that is successful
● void Duel.NegateRelatedChain (Card c, int reset)
So that card c has launched the chain are invalid, reset event occurs reset
● void Duel.NegateSummon (Card | Group targets)
So that the call is being summoned · reverse call special summoned targets invalid
● void Duel.IncreaseSummonedCount ([Card c])
Manual consumption of 1 player [for card c] the number of the usual call
● bool Duel.CheckSummonedCount ([Card c])
Check whether the round player can still summon this turn [Card c]
● int Duel.GetLocationCount (int player, int location [, int use_player, int reason = LOCATION_REASON_TOFIELD])
Returns the number of spaces available in the player's field
Location can only be LOCATION_MZONE or LOCATION_SZONE
Reason is LOCATION_REASON_TOFIELD or LOCATION_REASON_CONTROL
# # Additional parameters related to the effect of Caesar fighting field
● Card Duel.GetFieldCard (int player, int location, int seq)
Back to player The player's field is located in the location number seq card, commonly used to obtain the field area · Spirit pendulum area card
● bool Duel.CheckLocation (int player, int location, int seq)
Check if the player's player field is seq in the location of the space is available
● int Duel.GetCurrentChain ()
Returns the chain number currently being processed
● ... Duel.GetChainInfo (int chainc, ...)
Returns the chainc information, if chainc = 0, returns the chain of information currently being processed
This function returns the corresponding number of return values in sequence according to the number of arguments passed in. The arguments can be:
CHAININFO_CHAIN_COUNT The serial number of the chain
CHAININFO_TRIGGERING_EFFECT The effect of the chain
CHAININFO_TRIGGERING_PLAYER
CHAININFO_TRIGGERING_CONTROLER The player to which the chained position belongs
CHAININFO_TRIGGERING_LOCATION The location where the chain occurred
CHAININFO_TRIGGERING_SEQUENCE The number of the position where the chain occurred
CHAININFO_TARGET_CARDS Chain of object cards
CHAININFO_TARGET_PLAYER The target player for the chain
CHAININFO_TARGET_PARAM The object parameters of the chain
CHAININFO_DISABLE_REASON The chain is invalid for the effect of the effect
CHAININFO_DISABLE_PLAYER The chain is invalid for the reason the player
CHAININFO_CHAIN_ID The unique identifier for the chain
CHAININFO_TYPE Type of Chain Card (Monster, Magic, Trap)
CHAININFO_EXTTYPE The specific type of chain card (for example, monster, continuous magic, counterattack trap)
For example: