[RPG-MAKER.FR] Oniromancie: tout l'univers de RPG Maker en français

Domaine concerné: Plugin
Logiciel utilisé: RPGMV
bonjour
toujours dans l'optique d'avancer mon projet,
je voudrai faire un système qui permet de gérer automatiquement les image des acteur (face/character/Battler)
en fonction de leur classe.
par exemple l'acteur est Guerrier
...\img\faces\Guerrier.png
...\img\characters\Guerrier.png
..\img\sv_actors\Guerrier.png
si il est Mage
...\img\faces\Mage.png
...\img\characters\Mage.png
..\img\sv_actors\Mage.png
j'ai fait ceci mais cela n'a pas l'air de fonctionner

 
/*:
@plugindesc change les sprite selon la classe des acteur 
Version: Alpha 00.1 
@author Johnseed(SeedSoft)
@help
==================================================
Info
==================================================
Classvisual.js
==================================================
Note Tag
==================================================
actor note:
<Class Visual>
change les images des acteur en fonction de la classe
 
==================================================
Mise a jour
==================================================
 
==================================================
Plugin Params
==================================================
 
*/
var Imported = Imported || {};
SeedSoft.ClassVisual = true;
var SeedSoft = SeedSoft || {};
SeedSoft.ClassVisual = SeedSoft.ClassVisual || {};
(function(){
 
//=============================================================================
// DataManager
//=============================================================================
 
SeedSoft.ClassVisual.DataManager_isDatabaseLoaded = DataManager.isDatabaseLoaded;
DataManager.isDatabaseLoaded = function() {
    this.processClassVisualNote($dataActors);
return true;
};
 
DataManager.processClassVisualNote = function(actor) {
if (line.match(/<(?:CLASS VISUAL)>/i)) {
   var actor = $gameActors.actor();
    actor.setCharacterImage(actor.currentClass().name, 1);
    actor.setFaceImage(actor.currentClass().name, 1);
    actor.setBattlerImage(actor.currentClass().name);
}
};
})(SeedSoft.ClassVisual)

TypeError: Cannot read property 'length' of undefined at Function.BattleManager.cameraX (YEP_X_ActSeqPack3.js:642) at Game_Screen.updateBattleCamera (YEP_X_ActSeqPack3.js:814) at Game_Screen.update (YEP_X_ActSeqPack3.js:788) at Scene_Battle.update (rpg_scenes.js:2039) at Scene_Battle.update (YEP_BattleEngineCore.js:3935) at Function.SceneManager.updateScene (rpg_managers.js:1790) at Function.SceneManager.updateMain (rpg_managers.js:1756) at Function.SceneManager.update (rpg_managers.js:1682)

else if (line.match(/<(?:ENEMY LEVEL V):[ ](.*)\s*\/>/i)) { if ($gameVariables != null){ var value = $gameVariables.value(RegExp.$1); obj.sideviewBattler.push(String(value)); obj.sideviewBreathing = [2, 3].contains(Yanfly.Param.SVEBreathing); }else { var value = 0; obj.sideviewBattler.push(String(value)); obj.sideviewBreathing = [2, 3].contains(Yanfly.Param.SVEBreathing); } }

#============================================================================== # ¦ DataManager #============================================================================== module DataManager #-------------------------------------------------------------------------- # alias method: load_database #-------------------------------------------------------------------------- class <<self; alias load_database_ecl load_database; end def self.load_database load_database_ecl load_notetags_ecl end #-------------------------------------------------------------------------- # new method: load_notetags_aee #-------------------------------------------------------------------------- def self.load_notetags_ecl groups = [$data_enemies] for group in groups for obj in group next if obj.nil? obj.load_notetags_ecl end end end end # DataManager

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 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053

=begin #=============================================================================== Title: Map Screenshot Author: Hime Date: Dec 7, 2014 -------------------------------------------------------------------------------- ** Change log Dec 7, 2014 - added option to draw certain events Apr 15, 2013 - updated script to use GDI+ interface - added support for region map overlay and passage map overlay Apr 6, 2013 - fixed bug where drawing events crashed the game Apr 2, 2013 - map data is now setup by an instance of Game_Map, to account for custom map scripts adding to the map Jul 27 - Export dirNames are now optional May 28 - updated overlay mapping compatibility to draw the overlays based on the player's current position - fixed issue where import hash was commented out - Added support for Yami's overlay mapping May 24, 2012 - fixed large characters - some optimizations for calculating bounds and dimensions May 5, 2012 - fixed waterfall autotile - added screenshot feature May 4, 2012 - fixed tiles with alpha channel - fixed shadows - fixed wall autotiles May 1, 2012 - fixed wall autotile, although there is still an issue with some tiles Apr 29, 2012 - fixed shadow map drawing - added region highlighting - added damage tile highlighting Apr 28, 2012 - Initial Release ------------------------------------------------------------------------------ ** Description This script allows you to take a full image of any of your game's maps and export. An image of the map is referred to as a "mapshot" (as opposed to screenshot). The script provides various configuration options to control what kinds of things you want to see on your map, such as events, vehicles, region ID's, or specific tile properties. ------------------------------------------------------------------------------ ** Usage The default key for taking a mapshot is F7. This can be changed in the configuration section. To take a mapshot, first start the game, and then hit F7. A message will appear informing you that a mapshot was successfully taken. Alternatively, you can use script calls to take mapshots. Map_Saver.new(map_id).export Aside from exporting images, you are able to use the image that the map saver captures. ms = Map_Saver.new(map_id) bmp = ms.map_image This gives you a reference to a Bitmap object that contains an image of your map. -------------------------------------------------------------------------------- ** Credits Cremno -GDI+ interface code Cidiomar -for drawing autotiles and shadows, -providing efficient bmp and png exporters Moon -auto-tile related info Mephistox -testing and suggestions ================================================================================ =end $imported = {} if $imported.nil? $imported["TH_MapSaver"] = true #=============================================================================== # ** Configuration #=============================================================================== module TH module Map_Saver #Mapshot options. This takes an image of the entire map Mapshot_Button = Input::F7 Mapshot_Scale = 1 #Screenshot options. This takes an image of the visible map Screenshot_Button = Input::F6 Screenshot_Scale = 1 #Folder that the map will be exported to Mapshot_Directory = "Mapshots" Screenshot_Directory = "Screenshots" # format you want to export to. You should stick with png. # Options: [bmp, png] Export_Format = "png" # Sprite draw options Draw_Events = false Draw_Player = false Draw_Followers = false Draw_Vehicles = false #Should shadows be drawn? What color? Draw_Shadow = true Shadow_Color = Color.new(0, 0, 0, 128) # Should regions be drawn? Requires "Region Overlay Map" script Draw_Regions = false # Should passage settings be drawn? Requires "Passage Overlay Map" script Draw_Passages = false #Should damage tiles be highlighted? What color? Highlight_Damage = true Damage_Color = Color.new(128, 0, 0, 128) end end #============================================================================== # ** Module: Map_Tiles # Contains data and methods useful for working with maps and tiles #============================================================================== module Map_Tiles AUTOTILE_PARTS = [[18,17,14,13], [ 2,14,17,18], [13, 3,17,18], [ 2, 3,17,18], [13,14,17, 7], [ 2,14,17, 7], [13, 3,17, 7], [ 2, 3,17, 7], [13,14, 6,18], [ 2,14, 6,18], [13, 3, 6,18], [ 2, 3, 6,18], [13,14, 6, 7], [ 2,14, 6, 7], [13, 3, 6, 7], [ 2, 3, 6, 7], [16,17,12,13], [16, 3,12,13], [16,17,12, 7], [12, 3,16, 7], [10, 9,14,13], [10, 9,14, 7], [10, 9, 6,13], [10, 9, 6, 7], [18,19,14,15], [18,19, 6,15], [ 2,19,14,15], [ 2,19, 6,15], [18,17,22,21], [ 2,17,22,21], [18, 3,22,21], [ 2, 3,21,22], [16,19,12,15], [10, 9,22,21], [ 8, 9,12,13], [ 8, 9,12, 7], [10,11,14,15], [10,11, 6,15], [18,19,22,23], [ 2,19,22,23], [16,17,20,21], [16, 3,20,21], [ 8,11,12,15], [ 8, 9,20,21], [16,19,20,23], [10,11,22,23], [ 8,11,20,23], [ 0, 1, 4, 5]] WATERFALL_PIECES = [[ 2, 1, 6, 5], [ 0, 1, 4, 5], [ 2, 3, 6, 7], [0, 3, 4, 7]] WALL_PIECES = [[10, 9, 6, 5], [ 8, 9, 4, 5], [ 2, 1, 6, 5], [ 0, 1, 4, 5], [10,11, 6, 7], [ 8,11, 4, 7], [ 2, 3, 6, 7], [ 0, 3, 4, 7], [10, 9,14,13], [ 8, 9,12,13], [ 2, 1,14,13], [ 0, 1,12,13], [10,11,14,15], [8, 11,12,15], [ 2, 3,14,15], [ 0, 3,12,15]] A1_TILES = [[0, 0], [0, 96], [192, 0], [192, 96], [256, 0], [448, 0], [256, 96], [448, 96], [0, 192], [192, 192], [0, 288], [192, 288], [256, 192], [448, 192], [256, 288], [448, 288]] #-------------------------------------------------------------------------- # * Checks if a tile is a wall #-------------------------------------------------------------------------- def is_wall?(data) return true if data.between?(2288, 2335) return true if data.between?(2384, 2431) return true if data.between?(2480, 2527) return true if data.between?(2576, 2623) return true if data.between?(2672, 2719) return true if data.between?(2768, 2815) return true if data.between?(4736, 5119) return true if data.between?(5504, 5887) return true if data.between?(6272, 6655) return true if data.between?(7040, 7423) return true if data > 7807 false end #-------------------------------------------------------------------------- # * Checks if a tile is roof #-------------------------------------------------------------------------- def is_roof?(data) return true if data.between?(4352, 4735) return true if data.between?(5120, 5503) return true if data.between?(5888, 6271) return true if data.between?(6656, 7039) return true if data.between?(7424, 7807) false end #-------------------------------------------------------------------------- # * Checks if a tile is soil #-------------------------------------------------------------------------- def is_soil?(data) return true if data.between?(2816, 4351) && !is_table?(data) return true if data > 1663 && !is_stair?(data) false end #-------------------------------------------------------------------------- # * Checks if a tile is a stair #-------------------------------------------------------------------------- def is_stair?(data) return true if data.between?(1541, 1542) return true if data.between?(1549, 1550) return true if data.between?(1600, 1615) false end #-------------------------------------------------------------------------- # * Checks if a tile is a table #-------------------------------------------------------------------------- def is_table?(data) return true if data.between?(3152, 3199) return true if data.between?(3536, 3583) return true if data.between?(3920, 3967) return true if data.between?(4304, 4351) false end #-------------------------------------------------------------------------- # * The tileset to be used #-------------------------------------------------------------------------- def tileset $data_tilesets[@tileset_id] end #-------------------------------------------------------------------------- # * Region ID #-------------------------------------------------------------------------- def region_id(x, y) valid?(x, y) ? @map.data[x, y, 3] >> 8 : 0 end #-------------------------------------------------------------------------- # * Gets all of the tiles for each layer at position x,y #-------------------------------------------------------------------------- def layered_tiles(x, y) [2, 1, 0].collect {|z| @map.data[x, y, z] } end def layered_tiles_flag?(x, y, bit) layered_tiles(x, y).any? {|tile_id| tileset.flags[tile_id] & bit != 0 } end def valid?(x, y) x >= 0 && x < width && y >= 0 && y < height end def damage_floor?(x, y) valid?(x, y) && layered_tiles_flag?(x, y, 0x100) end #-------------------------------------------------------------------------- # * Specifies which type of autotile is used #-------------------------------------------------------------------------- def auto_tile(id) id / 48 end #-------------------------------------------------------------------------- # * Specifies the specific arrangement of autotiles used #-------------------------------------------------------------------------- def auto_index(id) id % 48 end #-------------------------------------------------------------------------- # * Put the auto-tile pieces together #-------------------------------------------------------------------------- def make_autotile(rects, sx, sy) @tile.clear for i in 0...4 @auto_rect.x = (rects[i] % 4) * 16 + sx @auto_rect.y = (rects[i] / 4) * 16 + sy @tile.blt((i % 2) * 16,(i / 2) * 16, @tilemap, @auto_rect) end end #-------------------------------------------------------------------------- # * Get auto-tile A1 tiles #-------------------------------------------------------------------------- def autotile_A1(tile_id) @tilemap = @bitmaps[0] autotile = tile_id / 48 auto_id = tile_id % 48 sx, sy = A1_TILES[autotile] if is_wall?(tile_id + 2048) rects = WATERFALL_PIECES[auto_id] else rects = AUTOTILE_PARTS[auto_id] end make_autotile(rects, sx, sy) end #-------------------------------------------------------------------------- # * Get auto-tile A2 tiles. # 64x96 tiles, 8 per row, 4 rows #-------------------------------------------------------------------------- def autotile_A2(tile_id) autotile = tile_id / 48 auto_id = tile_id % 48 @tilemap = @bitmaps[1] sx = (autotile % 8) * 64 sy = (autotile / 8 % 4) * 96 rects = AUTOTILE_PARTS[auto_id] make_autotile(rects, sx, sy) end #-------------------------------------------------------------------------- # * Get auto-tile A3 tiles. # 64x64 tiles, 8 per row, 4 rows #-------------------------------------------------------------------------- def autotile_A3(tid) @tilemap = @bitmaps[2] sx = (auto_tile(tid) % 8) * 64 sy = (auto_tile(tid) / 8 % 4) * 64 rects = WALL_PIECES[auto_index(tid)] make_autotile(rects, sx, sy) end #-------------------------------------------------------------------------- # * Get auto-tile A4 tiles (walls) #-------------------------------------------------------------------------- def autotile_A4(tile_id) @tilemap = @bitmaps[3] autotile = tile_id / 48 auto_id = tile_id % 48 sx = (autotile % 8) * 64 sy = (autotile / 16 * 160) + (autotile / 8 % 2) * 96 if is_wall?(tile_id + 5888) rects = WALL_PIECES[auto_id] else rects = AUTOTILE_PARTS[auto_id] end make_autotile(rects, sx, sy) end #-------------------------------------------------------------------------- # * Get auto-tile A5 tiles (normal) #-------------------------------------------------------------------------- def autotile_A5(tile_id) @tilemap = @bitmaps[4] sx = (tile_id) % 8 * tilesize sy = (tile_id) / 8 * tilesize @src_rect.set(sx, sy, tilesize, tilesize) @tile.clear @tile.blt(0, 0, @tilemap, @src_rect) end #-------------------------------------------------------------------------- # * Get normal tiles B, C, D, E #-------------------------------------------------------------------------- def normal_tile(tile_id) @tilemap = @bitmaps[5 + tile_id / 256] sx = (tile_id / 128 % 2 * 8 + tile_id % 8) * tilesize; sy = (tile_id % 256 / 8 % 16) * tilesize; @src_rect.set(sx, sy, tilesize, tilesize) @tile.clear @tile.blt(0, 0, @tilemap, @src_rect) end #-------------------------------------------------------------------------- # * Get bitmap for the specified tile id #-------------------------------------------------------------------------- def get_bitmap(id) if id < 1024 normal_tile(id) elsif id < 1664 autotile_A5(id - 1536) elsif id < 2816 autotile_A1(id - 2048) elsif id < 4352 autotile_A2(id - 2816) elsif id < 5888 autotile_A3(id - 4352) else autotile_A4(id - 5888) end end end #============================================================================== # ** #============================================================================== class Game_Player < Game_Character alias :th_mapsaver_update :update def update th_mapsaver_update if Input.trigger?(TH::Map_Saver::Mapshot_Button) s = Map_Saver.new($game_map.map_id) s.set_scale(TH::Map_Saver::Mapshot_Scale) s.mapshot end if Input.trigger?(TH::Map_Saver::Screenshot_Button) s = Map_Saver.new($game_map.map_id) s.set_scale(TH::Map_Saver::Screenshot_Scale) s.screenshot end end end class Game_Vehicle < Game_Character attr_reader :map_id end class Game_Map attr_reader :map end #============================================================================== # ** #============================================================================== class Map_Saver include TH::Map_Saver include Map_Tiles #-------------------------------------------------------------------------- # * Constants #-------------------------------------------------------------------------- SHADOW_COLOR = TH::Map_Saver::Shadow_Color DAMAGE_COLOR = TH::Map_Saver::Damage_Color #-------------------------------------------------------------------------- # * Public instance variables #-------------------------------------------------------------------------- attr_reader :map_image def initialize(map_id=$game_map.map_id, x=$game_player.x, y=$game_player.y) @scale = 1 @local_x = x @local_y = y @screen_local = false @shadow_bitmap = Bitmap.new(128, 128) @draw_layer0 = true @draw_layer1 = true @draw_layer2 = true @draw_events = Draw_Events @draw_vehicles = Draw_Vehicles @draw_player = Draw_Player @draw_followers = Draw_Followers @draw_shadow = Draw_Shadow @draw_damage = Highlight_Damage @draw_regions = Draw_Regions @draw_passages = Draw_Passages @tile = Bitmap.new(32, 32) #stores the current tile to be drawn @tilemap = nil @src_rect = Rect.new @auto_rect = Rect.new(0, 0, tilesize / 2, tilesize/ 2) #constant @tile_rect = Rect.new(0, 0, tilesize, tilesize) #constant end def load_tilesets bitmaps = [] tileset.tileset_names.each_with_index do |name, i| bitmaps[i] = Cache.tileset(name) end return bitmaps end #-------------------------------------------------------------------------- # * Refresh, possibly with a new map #-------------------------------------------------------------------------- def redraw(map_id=$game_map.map_id, x=$game_player.x, y=$game_player.y) @map_image.dispose if @map_image @map_id = map_id @local_x = x @local_y = y @game_map = Game_Map.new @game_map.setup(map_id) @map = @game_map.map @map_info = $data_mapinfos[map_id] @screen = $game_map.screen @tileset_id = @game_map.tileset.id @bitmaps = load_tilesets get_bounds @map_image = Bitmap.new(@width * tilesize, @height * tilesize) draw_map scale_map if @scale != 1 end #-------------------------------------------------------------------------- # * Pre-process. These will never change when drawing the map. #-------------------------------------------------------------------------- def get_bounds @start_x = start_x @start_y = start_y @end_x = end_x @end_y = end_y @width = width @height = height @tilesize = tilesize end def screen_tile_x Graphics.width / 32 end def screen_tile_y Graphics.height / 32 end #-------------------------------------------------------------------------- # * Sets the scale for the map #-------------------------------------------------------------------------- def set_scale(scale) @scale = scale end #-------------------------------------------------------------------------- # * Size of a tile #-------------------------------------------------------------------------- def tilesize 32 end #-------------------------------------------------------------------------- # * Width and height of the map, both locally and globally #-------------------------------------------------------------------------- def width end_x - @start_x end def height end_y - @start_y end #-------------------------------------------------------------------------- # * Starting and end positions, relative to the screen or map #-------------------------------------------------------------------------- def start_x @screen_local ? [[$game_player.x - screen_tile_x / 2, @map.width - screen_tile_x].min, 0].max : 0 end def start_y @screen_local ? [[$game_player.y - screen_tile_y / 2, @map.height - screen_tile_y].min, 0].max : 0 end def end_x @screen_local ? [[screen_tile_x, @local_x + screen_tile_x / 2 + 1].max, @map.width].min : @map.width end def end_y @screen_local ? [[screen_tile_y, @local_y + screen_tile_y / 2 + 1].max, @map.height].min : @map.height end #-------------------------------------------------------------------------- # * Draw tile onto image. x and y values are absolute coords. They should # be re-mapped based on the start_x and start_y values #-------------------------------------------------------------------------- def draw_tile(x, y, tile, rect) ox = (x - @start_x) * tilesize oy = (y - @start_y) * tilesize @map_image.blt(ox, oy, tile, rect) end #-------------------------------------------------------------------------- # * Get bitmap for the specified character #-------------------------------------------------------------------------- def get_character_bitmap(name) charmap = Cache.character(name) sign = name[/^[\!\$]./] if sign && sign.include?('$') cw = charmap.width / 3 ch = charmap.height / 4 else cw = charmap.width / 12 ch = charmap.height / 8 end return charmap, cw, ch end #-------------------------------------------------------------------------- # * Draw the character onto the tile #-------------------------------------------------------------------------- def set_character_bitmap(character, x, y) charmap, cw, ch = get_character_bitmap(character.character_name) index = character.character_index pattern = character.pattern < 3 ? character.pattern : 1 sx = (index % 4 * 3 + pattern) * cw sy = (index / 4 * 4 + (character.direction - 2) / 2) * ch @src_rect.set(sx, sy, cw, ch) x -= cw / (@tilesize * 2) if cw >= @tilesize y -= ch / (@tilesize * 2) if ch >= @tilesize draw_tile(x, y, charmap, @src_rect) end #-------------------------------------------------------------------------- # * create the shadow map #-------------------------------------------------------------------------- def make_shadow_map for s in 0 ... 16 x = s % 4 y = s / 4 if s & 0b1000 == 0b1000 @shadow_bitmap.fill_rect(x*tilesize+16, y*@tilesize+16, 16, 16, SHADOW_COLOR) end if s & 0b0100 == 0b0100 @shadow_bitmap.fill_rect(x*tilesize, y*@tilesize+16, 16, 16, SHADOW_COLOR) end if s & 0b0010 == 0b0010 @shadow_bitmap.fill_rect(x*tilesize+16, y*@tilesize, 16, 16, SHADOW_COLOR) end if s & 0b0001 == 0b0001 @shadow_bitmap.fill_rect(x*tilesize, y*@tilesize, 16, 16, SHADOW_COLOR) end end end def draw_parallax image = Cache.parallax(@map.parallax_name) @src_rect.set(0, 0, image.width, image.height) @map_image.blt(0, 0, image, @src_rect) end #-------------------------------------------------------------------------- # * Draw the shadow map #-------------------------------------------------------------------------- def draw_shadow_map for x in @start_x ... @end_x for y in @start_y ... @end_y _x, _y = x*@tilesize, y*@tilesize s = @map.data[x, y, 3] & 0b1111 if s != 0 x_ = (s % 4) * @tilesize y_ = (s / 4) * @tilesize @src_rect.set(x_, y_, @tilesize, @tilesize) draw_tile(x, y, @shadow_bitmap, @src_rect) end end end end #-------------------------------------------------------------------------- # * Draw the specified layer #-------------------------------------------------------------------------- def draw_layer(layer) for x in @start_x ... @end_x for y in @start_y ... @end_y _x, _y = x*@tilesize, y*@tilesize tile_id = @map.data[x, y, layer] next if tile_id == 0 get_bitmap(tile_id) draw_tile(x, y, @tile, @tile_rect) end end end #----------------------------------------------------------------------------- # Draw game regions #----------------------------------------------------------------------------- def draw_regions if $imported["TH_RegionOverlay"] image = SceneManager.scene.instance_variable_get(:@spriteset).instance_variable_get(:@region_map).bitmap @src_rect.set(@start_x * tilesize, @start_y * tilesize, image.width, image.height) @map_image.blt(0, 0, image, @src_rect, 255) end end def draw_passages if $imported["TH_OverlayPassageMap"] image = SceneManager.scene.instance_variable_get(:@spriteset).instance_variable_get(:@passage_map).bitmap @src_rect.set(@start_x * tilesize, @start_y * tilesize, image.width, image.height) @map_image.blt(0, 0, image, @src_rect, 255) end end #-------------------------------------------------------------------------- # * Draw the game player #-------------------------------------------------------------------------- def draw_player set_character_bitmap($game_player, $game_player.x, $game_player.y) if @map_id == $game_map.map_id end def draw_followers end #-------------------------------------------------------------------------- # * Draw map events #-------------------------------------------------------------------------- def draw_events @map.events.values.each do |event| canDraw = event.pages[0].list.any? do |cmd| cmd.code == 108 && cmd.parameters[0] =~ /<screenshot:\s*tile\s*>/i end next unless @draw_events || canDraw id = event.pages[0].graphic.tile_id char_name = event.pages[0].graphic.character_name if id > 0 normal_tile(id) draw_tile(event.x, event.y, @tilemap, @src_rect) elsif char_name != "" set_character_bitmap(event.pages[0].graphic, event.x, event.y) end end end #-------------------------------------------------------------------------- # * Draw map vehicles #-------------------------------------------------------------------------- def draw_vehicles $game_map.vehicles.each do |vehicle| set_character_bitmap(vehicle, vehicle.x, vehicle.y,) if @map_id == vehicle.map_id end end #-------------------------------------------------------------------------- # * Draw map sprites #-------------------------------------------------------------------------- def draw_sprites draw_events draw_vehicles if @draw_vehicles draw_player if @draw_player draw_followers if @draw_followers end #-------------------------------------------------------------------------- # * Highlight damage tiles #-------------------------------------------------------------------------- def draw_damage @tile.clear @tile.fill_rect(0, 0, @tilesize, @tilesize, DAMAGE_COLOR) @src_rect.set(0, 0, @tilesize, @tilesize) for x in @start_x ... @end_x for y in @start_y ... @end_y _x, _y = x*@tilesize, y*@tilesize if damage_floor?(x, y) draw_tile(x, y, @tile, @src_rect) end end end end def draw_screen_effects end #-------------------------------------------------------------------------- # * Draw the map #-------------------------------------------------------------------------- def draw_map make_shadow_map if @draw_shadow draw_parallax draw_layer(0) draw_layer(1) draw_shadow_map draw_layer(2) draw_damage if @draw_damage draw_regions if @draw_regions draw_passages if @draw_passages draw_sprites draw_screen_effects end #-------------------------------------------------------------------------- # * Scale the map #-------------------------------------------------------------------------- def scale_map nw = @width * @scale nh = @height * @scale @src_rect.set(0, 0, @width, @height) scaled_map = Bitmap.new(nw, nh) scaled_rect = Rect.new(0, 0, nw, nh) scaled_map.stretch_blt(scaled_rect, @map_image, @src_rect) @map_image = scaled_map end #-------------------------------------------------------------------------- # * Take a mapshot of the map #-------------------------------------------------------------------------- def mapshot @screen_local = false redraw export(TH::Map_Saver::Mapshot_Directory) $game_message.add("Mapshot taken") end #-------------------------------------------------------------------------- # * Take a screenshot of the map #-------------------------------------------------------------------------- def screenshot @screen_local = true redraw export(TH::Map_Saver::Screenshot_Directory) $game_message.add("Screenshot taken") end #-------------------------------------------------------------------------- # * Get the format to export to #-------------------------------------------------------------------------- def get_format TH::Map_Saver::Export_Format end #-------------------------------------------------------------------------- # * Export the map to a file #-------------------------------------------------------------------------- def export(dirName="") format = get_format #name = @map.display_name != "" ? @map.display_name : @map_info.name name = sprintf("Map%03d" %[@map_id]) Dir.mkdir(dirName) unless File.directory?(dirName) name = filename = "%s\\%s.%s" %[dirName, name, format] t1 = Time.now @map_image.save(filename) t2 = Time.now $game_message.add("Exported in %f seconds" %[t2 - t1]) end end class Bitmap def save(filename, options = {}) options.merge!(format: File.extname(filename)[1..-1].to_sym) retval = false #bitmap = Gdiplus::Bitmap.new(:hbitmap, hbitmap) #bitmap = Gdiplus::Bitmap.new(:gdidib, *gdidib) # this seems to be the fastest one (RGSS 3.0.1, Windows 8 64-bit) bitmap = Gdiplus::Bitmap.new(:scan0, width, height, scan0) if bitmap retval = bitmap.save(:file, filename, options[:format]) bitmap.dispose end retval end private def _data_struct(offset = 0) @_data_struct ||= (DL::CPtr.new((object_id << 1) + 16).ptr + 8).ptr (@_data_struct + offset).ptr.to_i end def gdidib [_data_struct(8), _data_struct(16)] end def hbitmap _data_struct(44) end def scan0 _data_struct(12) end end # ★ GDI+ interface # ★★★★★★★★★★★★ # # Author : Cremno # module Gdiplus DLL = 'gdiplus.dll' def self.get_function name, import, export = 'L' Win32API.new DLL, name, import, export end FUNCTIONS = { GdiplusStartup: get_function('GdiplusStartup', 'PPP'), GdiplusShutdown: get_function('GdiplusShutdown', 'P', 'V'), GdipDisposeImage: get_function('GdipDisposeImage', 'P'), GdipSaveImageToFile: get_function('GdipSaveImageToFile', 'PPPP'), GdipCreateBitmapFromGdiDib: get_function('GdipCreateBitmapFromGdiDib', 'LLP'), GdipCreateBitmapFromHBITMAP: get_function('GdipCreateBitmapFromHBITMAP', 'LLP'), GdipCreateBitmapFromScan0: get_function('GdipCreateBitmapFromScan0', 'LLLLPP') } @@token = [0].pack('I') def self.token @@token end @@clsids = {} def self.clsids @@clsids end def self.gen_clsids return unless @@clsids.empty? func = Win32API.new('rpcrt4.dll', 'UuidFromString', 'PP', 'L') { bmp: '557cf400-1a04-11d3-9a73-0000f81ef32e', jpeg: '557cf401-1a04-11d3-9a73-0000f81ef32e', gif: '557cf402-1a04-11d3-9a73-0000f81ef32e', tiff: '557cf405-1a04-11d3-9a73-0000f81ef32e', png: '557cf406-1a04-11d3-9a73-0000f81ef32e' }.each_pair do |k, v| clsid = [0].pack('I') func.call(v, clsid) @@clsids[k] = clsid end @@clsids[:jpg] = @@clsids[:jpeg] @@clsids[:tif] = @@clsids[:tiff] end # TODO: prepend prefix (Gdip or Gdiplus) automatically def self.call(*args) name = args.shift func = FUNCTIONS[name] v = func.call(*args) if v && v != 0 msgbox "GDI+ error: #{v}\n\nFunction: #{name}\nArguments: #{args.inspect}" false else true end end def self.startup call :GdiplusStartup, @@token, [1, 0, 0, 0].pack('L4'), 0 end def self.shutdown call :GdiplusShutdown, @@token end class Image attr_reader :instance def initialize @instance = 0 true end def save(destination, *args) case destination when :file filename = args.shift << "\0" filename.encode!('UTF-16LE') argv = [:GdipSaveImageToFile, filename, Gdiplus.clsids[args.shift], 0] else raise ArgumentError, "unknown GDI+ image destination: #{source}" end argv.insert(1, @instance) Gdiplus.call *argv end def dispose Gdiplus.call :GdipDisposeImage, @instance end end class Bitmap < Image def initialize source, *args case source when :gdidib argv = [:GdipCreateBitmapFromGdiDib, args.shift, args.shift] when :hbitmap argv = [:GdipCreateBitmapFromHBITMAP, args.shift, 0] when :scan0 w = args.shift h = args.shift argv = [:GdipCreateBitmapFromScan0, w, h, w * -4, 0x26200a, args.shift] else raise ArgumentError, "unknown GDI+ bitmap source: #{source}" end argv.push([0].pack('I')) retval = Gdiplus.call *argv @instance = retval ? argv.last.unpack('I').first : 0 retval end end end if Gdiplus.startup Gdiplus.gen_clsids class << SceneManager alias_method :run_wo_gdip_shutdown, :run def run run_wo_gdip_shutdown Gdiplus.shutdown end end end #============================================================================== # * Compatibility add-ons #============================================================================== #Yami overlays if $imported["YSE-OverlayMapping"] class Map_Saver def draw_overlay_map_ground filename = YSA::OVERLAY::GROUND filename += $game_map.map_id.to_s filename += "-" + $game_variables[YSA::OVERLAY::GROUND_VARIABLE].to_s p filename image = Cache.overlay(filename) @src_rect.set(@start_x*tilesize, @start_y*tilesize, image.width, image.height) @map_image.blt(0, 0, image, @src_rect) end def draw_overlay_map_parallax filename = YSA::OVERLAY::PARALLAX filename += $game_map.map_id.to_s filename += "-" + $game_variables[YSA::OVERLAY::PARALLAX_VARIABLE].to_s image = Cache.overlay(filename) @src_rect.set(@start_x*tilesize, @start_y*tilesize, image.width, image.height) @map_image.blt(0, 0, image, @src_rect) end def draw_overlay_map_light filename = YSA::OVERLAY::LIGHT filename += $game_map.map_id.to_s filename += "-" + $game_variables[YSA::OVERLAY::LIGHT_VARIABLE].to_s image = Cache.overlay(filename) @src_rect.set(@start_x*tilesize, @start_y*tilesize, image.width, image.height) @map_image.blt(0, 0, image, @src_rect, 10) end def draw_overlay_map_shadow filename = YSA::OVERLAY::SHADOW filename += $game_map.map_id.to_s filename += "-" + $game_variables[YSA::OVERLAY::SHADOW_VARIABLE].to_s image = Cache.overlay(filename) @src_rect.set(@start_x*tilesize, @start_y*tilesize, image.width, image.height) @map_image.blt(0, 0, image, @src_rect, 10) end alias :th_map_overlay_draw_map :draw_map def draw_map th_map_overlay_draw_map draw_overlay_map_ground if $game_switches[YSA::OVERLAY::GROUND_SWITCH] draw_overlay_map_parallax if $game_switches[YSA::OVERLAY::PARALLAX_SWITCH] draw_overlay_map_shadow if $game_switches[YSA::OVERLAY::SHADOW_SWITCH] draw_overlay_map_light if $game_switches[YSA::OVERLAY::LIGHT_SWITCH] end end end if $imported["TH_AreaOverlay"] class Map_Saver def draw_overlay_area_map image = SceneManager.scene.instance_variable_get(:@spriteset).instance_variable_get(:@area_map).bitmap @src_rect.set(@start_x * tilesize, @start_y * tilesize, image.width, image.height) @map_image.blt(0, 0, image, @src_rect, 255) end alias :th_area_overlay_draw_map :draw_map def draw_map th_area_overlay_draw_map draw_overlay_area_map end end end

=begin #=============================================================================== Title: Map Screenshot - Pictures Author: Hime Date: Apr 22, 2014 -------------------------------------------------------------------------------- ** Change log Apr 22, 2014 - initial release -------------------------------------------------------------------------------- ** Terms of Use * Free to use in commercial/non-commercial projects * No real support. The script is provided as-is * Will do bug fixes, but no compatibility patches * Features may be requested but no guarantees, especially if it is non-trivial * Credits to Hime Works in your project * Preserve this header -------------------------------------------------------------------------------- ** Description This is an add-on for Map Screenshot that allows you to draw any pictures that are shown on the map. -------------------------------------------------------------------------------- ** Installation In the script editor, install this script below Map Screenshot and above Main -------------------------------------------------------------------------------- ** Usage Plug and play. #=============================================================================== =end $imported = {} if $imported.nil? $imported[:TH_MapScreenshotPictures] = true #=============================================================================== # ** Rest of Script #=============================================================================== class Map_Saver alias :th_map_screenshot_pictures_draw_screen_effects :draw_screen_effects def draw_screen_effects th_map_screenshot_pictures_draw_screen_effects draw_pictures end def draw_pictures $game_map.screen.pictures.each do |pic| bmp = Cache.picture(pic.name) x = pic.x y = pic.y opc = pic.opacity @map_image.blt(x, y, bmp, bmp.rect, opc) end end end

#============================================================================== # # ¥ Yanfly Engine Ace - Skill Restrictions v1.03 # -- Last Updated: 2012.07.21 # -- Level: Normal, Hard, Lunatic # -- Requires: n/a # #============================================================================== $imported = {} if $imported.nil? $imported["YEA-SkillRestrictions"] = true #============================================================================== # ¥ Updates # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= # 2012.07.21 - Fixed cooldown issue with Normal Attack and Defend. # 2012.01.23 - Compatibility Update: Doppelganger # 2011.12.12 - Started Script and Finished. # - Added cooldown altering notetags for items. # #============================================================================== # ¥ Introduction # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= # Sometimes good game balance depends on restriction mechanics. Of these # mechanics include skill cooldowns, warmups, and the amount of times a skill # can be used (limited uses). Included in this script are features also to # lock cooldowns, reduce cooldown rates, change cooldown values for skills, # skill types, and more. If this isn't enough restriction power, switches may # be used to restrict skills from being used as well as even code. # #============================================================================== # ¥ Instructions # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= # To install this script, open up your script editor and copy/paste this script # to an open slot below ¥ Materials/‘fÞ but above ¥ Main. Remember to save. # # ----------------------------------------------------------------------------- # Actor Notetags - These notetags go in the actors notebox in the database. # ----------------------------------------------------------------------------- # <cooldown lock> # A battler afflicted with cooldown lock will not have cooldowns count down # every turn until the cooldown lock is removed. # # <cooldown rate: x%> # When cooldowns are applied from using skills in battle, the cooldown rate can # reduce or increase the finalized amount of turns a battler would need to wait # before being able to use that skill again. # # <warmup rate: x%> # Lowers/Raises the amount of turns needed to pass in battle before the warmup # skills become available for usage. # # ----------------------------------------------------------------------------- # Class Notetags - These notetags go in the class notebox in the database. # ----------------------------------------------------------------------------- # <cooldown lock> # A battler afflicted with cooldown lock will not have cooldowns count down # every turn until the cooldown lock is removed. # # <cooldown rate: x%> # When cooldowns are applied from using skills in battle, the cooldown rate can # reduce or increase the finalized amount of turns a battler would need to wait # before being able to use that skill again. # # <warmup rate: x%> # Lowers/Raises the amount of turns needed to pass in battle before the warmup # skills become available for usage. # # ----------------------------------------------------------------------------- # Skill Notetags - These notetags go in the skills notebox in the database. # ----------------------------------------------------------------------------- # <cooldown: x> # Causes the skill to have a cooldown of x once it's used in battle. Skills # with cooldowns cannot be used again until cooldown reaches 0 or until the # battle is over. # # <change cooldown: +x> # <change cooldown: -x> # This will cause the target's cooldowns for every skill to increase by x or # decrease by x. This selects skills indiscriminately. # # <skill cooldown x: +y> # <skill cooldown x: -y> # This will cause the target's specific skill x to receive a change in cooldown # by either an increase or decrease of y amount. # # <stype cooldown x: +y> # <stype cooldown x: -y> # This will cause all of the skills with skill type x to have its cooldowns # changed by y amount. +y increases cooldown turns while -y decreases turns. # # <limited uses: x> # This will allow the skill to only be usable x times throughout the course of # battle. Once the skill is used x times, it is disabled until the battle is # over. This effect only takes place during battle. # # <warmup: x> # Causes the skill to be sealed until the x turns pass in battle. There's no # way to speed up a warmup manually with the exception of warmup rates. # # <restrict if switch: x> # This will restrict the skill if switch x is ON. If switch x is OFF, this # skill will no longer be restricted. # # <restrict any switch: x> # <restrict any switch: x, x> # This will restrict the skill if any of the x switches are ON. If all of them # are off, then the skill will not be restricted. # # <restrict all switch: x> # <restrict all switch: x, x> # This will restrict the skill if all of the x switches are ON. If any of them # are off, then the skill will not be restricted. # # <restrict eval> # string # string # </restrict eval> # For the more advanced users, replace string with code to determine whether # or not the skill is restricted. If multiple lines are used, they are all # considered part of the same line. # # ----------------------------------------------------------------------------- # Item Notetags - These notetags go in the items notebox in the database. # ----------------------------------------------------------------------------- # <change cooldown: +x> # <change cooldown: -x> # This will cause the target's cooldowns for every skill to increase by x or # decrease by x. This selects skills indiscriminately. # # <skill cooldown x: +y> # <skill cooldown x: -y> # This will cause the target's specific skill x to receive a change in cooldown # by either an increase or decrease of y amount. # # <stype cooldown x: +y> # <stype cooldown x: -y> # This will cause all of the skills with skill type x to have its cooldowns # changed by y amount. +y increases cooldown turns while -y decreases turns. # # ----------------------------------------------------------------------------- # Weapon Notetags - These notetags go in the weapons notebox in the database. # ----------------------------------------------------------------------------- # <cooldown lock> # A battler afflicted with cooldown lock will not have cooldowns count down # every turn until the cooldown lock is removed. # # <cooldown rate: x%> # When cooldowns are applied from using skills in battle, the cooldown rate can # reduce or increase the finalized amount of turns a battler would need to wait # before being able to use that skill again. # # <warmup rate: x%> # Lowers/Raises the amount of turns needed to pass in battle before the warmup # skills become available for usage. # # ----------------------------------------------------------------------------- # Armour Notetags - These notetags go in the armours notebox in the database. # ----------------------------------------------------------------------------- # <cooldown lock> # A battler afflicted with cooldown lock will not have cooldowns count down # every turn until the cooldown lock is removed. # # <cooldown rate: x%> # When cooldowns are applied from using skills in battle, the cooldown rate can # reduce or increase the finalized amount of turns a battler would need to wait # before being able to use that skill again. # # <warmup rate: x%> # Lowers/Raises the amount of turns needed to pass in battle before the warmup # skills become available for usage. # # ----------------------------------------------------------------------------- # Enemy Notetags - These notetags go in the enemies notebox in the database. # ----------------------------------------------------------------------------- # <cooldown lock> # A battler afflicted with cooldown lock will not have cooldowns count down # every turn until the cooldown lock is removed. # # <cooldown rate: x%> # When cooldowns are applied from using skills in battle, the cooldown rate can # reduce or increase the finalized amount of turns a battler would need to wait # before being able to use that skill again. # # <warmup rate: x%> # Lowers/Raises the amount of turns needed to pass in battle before the warmup # skills become available for usage. # # ----------------------------------------------------------------------------- # State Notetags - These notetags go in the states notebox in the database. # ----------------------------------------------------------------------------- # <cooldown lock> # A battler afflicted with cooldown lock will not have cooldowns count down # every turn until the cooldown lock is removed. # # <cooldown rate: x%> # When cooldowns are applied from using skills in battle, the cooldown rate can # reduce or increase the finalized amount of turns a battler would need to wait # before being able to use that skill again. # # <warmup rate: x%> # Lowers/Raises the amount of turns needed to pass in battle before the warmup # skills become available for usage. # #============================================================================== # ¥ Compatibility # =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= # This script is made strictly for RPG Maker VX Ace. It is highly unlikely that # it will run with RPG Maker VX without adjusting. # #============================================================================== module YEA module SKILL_RESTRICT #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- # - Cooldown Settings - #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- # Skills with cooldowns cannot be used for some number of turns. Adjust the # settings here on how cooldowns appear in the menu. Cooldowns are only # applied in battle. #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- COOLDOWN_COLOUR = 6 # Colour used from "Window" skin. COOLDOWN_SIZE = 20 # Font size used for cooldowns. COOLDOWN_SUFFIX = "%sCD" # Suffix used for cooldowns. COOLDOWN_ICON = 0 # Icon used for cooldowns. Set 0 to disable. #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- # - Warmup Settings - #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- # Skills with warmups are unaffected by cooldowns. They become available to # use after a certain number of turns have passed. Warmups are only applied # in battle. Cooldown Rates do not affect warmups but Warmup Rates do. #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- WARMUP_COLOUR = 5 # Colour used from "Window" skin. WARMUP_SIZE = 20 # Font size used for warmups. WARMUP_SUFFIX = "%sWU" # Suffix used for warmups. WARMUP_ICON = 0 # Icon used for warmups. Set 0 to disable. #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- # - Limited Use Settings - #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- # Some skills have limited uses per battle. These limited uses are reset # at the start and end of each battle and do not apply when used outside of # battle. There are no effects that can affect limited uses. #=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=- LIMITED_COLOUR = 8 # Colour used from "Window" skin. LIMITED_SIZE = 16 # Font size used for used up. LIMITED_TEXT = "Used" # Text used for used up. LIMITED_ICON = 0 # Icon used for used up. Set 0 to disable. end # SKILL_RESTRICT end # YEA #============================================================================== # ¥ Editting anything past this point may potentially result in causing # computer damage, incontinence, explosion of user's head, coma, death, and/or # halitosis so edit at your own risk. #============================================================================== module YEA module REGEXP module BASEITEM COOLDOWN_RATE = /<(?:COOL_DOWN_RATE|cooldown rate):[ ](\d+)([%“])>/i COOLDOWN_LOCK = /<(?:COOL_DOWN_LOCK|cooldown lock)>/i WARMUP_RATE = /<(?:WARM_UP_RATE|warmup rate):[ ](\d+)([%“])>/i end # BASEITEM module SKILL COOLDOWN = /<(?:COOL_DOWN|cooldown):[ ](\d+)>/i WARMUP = /<(?:WARM_UP|warmup):[ ](\d+)>/i LIMITED_USES = /<(?:LIMITED_USES|limited uses):[ ](\d+)>/i CHANGE_COOLDOWN = /<(?:CHANGE_COOL_DOWN|change cooldown):[ ]([\+\-]\d+)>/i STYPE_COOLDOWN = /<(?:STYPE_COOL_DOWN|stype cooldown)[ ](\d+):[ ]([\+\-]\d+)>/i SKILL_COOLDOWN = /<(?:SKILL_COOL_DOWN|skill cooldown)[ ](\d+):[ ]([\+\-]\d+)>/i RESTRICT_IF_SWITCH = /<(?:RESTRICT_IF_SWITCH|restrict if switch):[ ](\d+)>/i RESTRICT_ANY_SWITCH = /<(?:RESTRICT_ANY_SWITCH|restrict any switch):[ ]*(\d+(?:\s*,\s*\d+)*)>/i RESTRICT_ALL_SWITCH = /<(?:RESTRICT_ALL_SWITCH|restrict all switch):[ ]*(\d+(?:\s*,\s*\d+)*)>/i RESTRICT_EVAL_ON = /<(?:RESTRICT_EVAL|restrict eval)>/i RESTRICT_EVAL_OFF = /<\/(?:RESTRICT_EVAL|restrict eval)>/i end # SKILL module ITEM CHANGE_COOLDOWN = /<(?:CHANGE_COOL_DOWN|change cooldown):[ ]([\+\-]\d+)>/i STYPE_COOLDOWN = /<(?:STYPE_COOL_DOWN|stype cooldown)[ ](\d+):[ ]([\+\-]\d+)>/i SKILL_COOLDOWN = /<(?:SKILL_COOL_DOWN|skill cooldown)[ ](\d+):[ ]([\+\-]\d+)>/i end # ITEM end # REGEXP end # YEA #============================================================================== # ¡ Icon #============================================================================== module Icon #-------------------------------------------------------------------------- # self.cooldown #-------------------------------------------------------------------------- def self.cooldown; return YEA::SKILL_RESTRICT::COOLDOWN_ICON; end #-------------------------------------------------------------------------- # self.warmup #-------------------------------------------------------------------------- def self.warmup; return YEA::SKILL_RESTRICT::WARMUP_ICON; end #-------------------------------------------------------------------------- # self.limited #-------------------------------------------------------------------------- def self.limited; return YEA::SKILL_RESTRICT::LIMITED_ICON; end end # Icon #============================================================================== # ¡ Numeric #============================================================================== class Numeric #-------------------------------------------------------------------------- # new method: group_digits #-------------------------------------------------------------------------- unless $imported["YEA-CoreEngine"] def group; return self.to_s; end end # $imported["YEA-CoreEngine"] end # Numeric #============================================================================== # ¡ DataManager #============================================================================== module DataManager #-------------------------------------------------------------------------- # alias method: load_database #-------------------------------------------------------------------------- class <<self; alias load_database_srs load_database; end def self.load_database load_database_srs load_notetags_srs end #-------------------------------------------------------------------------- # new method: load_notetags_srs #-------------------------------------------------------------------------- def self.load_notetags_srs groups = [$data_actors, $data_classes, $data_skills, $data_weapons, $data_armors, $data_enemies, $data_states, $data_items] for group in groups for obj in group next if obj.nil? obj.load_notetags_srs end end end end # DataManager #============================================================================== # ¡ RPG::BaseItem #============================================================================== class RPG::BaseItem #-------------------------------------------------------------------------- # public instance variables #-------------------------------------------------------------------------- attr_accessor :cooldown_rate attr_accessor :cooldown_lock attr_accessor :warmup_rate #-------------------------------------------------------------------------- # common cache: load_notetags_srs #-------------------------------------------------------------------------- def load_notetags_srs @cooldown_rate = 1.0 @warmup_rate = 1.0 #--- self.note.split(/[\r\n]+/).each { |line| case line #--- when YEA::REGEXP::BASEITEM::COOLDOWN_RATE @cooldown_rate = $1.to_i * 0.01 when YEA::REGEXP::BASEITEM::COOLDOWN_LOCK @cooldown_lock = true when YEA::REGEXP::BASEITEM::WARMUP_RATE @warmup_rate = $1.to_i * 0.01 #--- end } # self.note.split #--- end end # RPG::BaseItem #============================================================================== # ¡ RPG::Skill #============================================================================== class RPG::Skill < RPG::UsableItem #-------------------------------------------------------------------------- # public instance variables #-------------------------------------------------------------------------- attr_accessor :cooldown attr_accessor :warmup attr_accessor :limited_uses attr_accessor :change_cooldown attr_accessor :skill_cooldown attr_accessor :restrict_any_switch attr_accessor :restrict_all_switch attr_accessor :restrict_eval #-------------------------------------------------------------------------- # common cache: load_notetags_srs #-------------------------------------------------------------------------- def load_notetags_srs @cooldown = 0 @warmup = 0 @limited_uses = 0 @change_cooldown = {} @skill_cooldown = {} @restrict_any_switch = [] @restrict_all_switch = [] @restrict_eval = "" @restrict_eval_on = false #--- self.note.split(/[\r\n]+/).each { |line| case line #--- when YEA::REGEXP::SKILL::COOLDOWN @cooldown = $1.to_i when YEA::REGEXP::SKILL::WARMUP @warmup = $1.to_i when YEA::REGEXP::SKILL::LIMITED_USES @limited_uses = $1.to_i #--- when YEA::REGEXP::SKILL::CHANGE_COOLDOWN @change_cooldown[0] = $1.to_i when YEA::REGEXP::SKILL::STYPE_COOLDOWN @change_cooldown[$1.to_i] = $2.to_i when YEA::REGEXP::SKILL::SKILL_COOLDOWN @skill_cooldown[$1.to_i] = $2.to_i #--- when YEA::REGEXP::SKILL::RESTRICT_IF_SWITCH @restrict_any_switch.push($1.to_i) when YEA::REGEXP::SKILL::RESTRICT_ANY_SWITCH $1.scan(/\d+/).each { |num| @restrict_any_switch.push(num.to_i) if num.to_i > 0 } when YEA::REGEXP::SKILL::RESTRICT_ALL_SWITCH $1.scan(/\d+/).each { |num| @restrict_all_switch.push(num.to_i) if num.to_i > 0 } #--- when YEA::REGEXP::SKILL::RESTRICT_EVAL_ON @restrict_eval_on = true when YEA::REGEXP::SKILL::RESTRICT_EVAL_OFF @restrict_eval_off = true else @restrict_eval += line.to_s if @restrict_eval_on #--- end } # self.note.split #--- end end # RPG::Skill #============================================================================== # ¡ RPG::Item #============================================================================== class RPG::Item < RPG::UsableItem #-------------------------------------------------------------------------- # public instance variables #-------------------------------------------------------------------------- attr_accessor :change_cooldown attr_accessor :skill_cooldown #-------------------------------------------------------------------------- # common cache: load_notetags_srs #-------------------------------------------------------------------------- def load_notetags_srs @change_cooldown = {} @skill_cooldown = {} #--- self.note.split(/[\r\n]+/).each { |line| case line #--- when YEA::REGEXP::ITEM::CHANGE_COOLDOWN @change_cooldown[0] = $1.to_i when YEA::REGEXP::ITEM::STYPE_COOLDOWN @change_cooldown[$1.to_i] = $2.to_i when YEA::REGEXP::ITEM::SKILL_COOLDOWN @skill_cooldown[$1.to_i] = $2.to_i #--- end } # self.note.split #--- end end # RPG::Item #============================================================================== # ¡ Game_BattlerBase #============================================================================== class Game_BattlerBase #-------------------------------------------------------------------------- # alias method: initialize #-------------------------------------------------------------------------- alias game_battlerbase_initialize_srs initialize def initialize game_battlerbase_initialize_srs reset_cooldowns reset_times_used end #-------------------------------------------------------------------------- # new method: reset_cooldowns #-------------------------------------------------------------------------- def reset_cooldowns @cooldown = {} end #-------------------------------------------------------------------------- # new method: reset_times_used #-------------------------------------------------------------------------- def reset_times_used @times_used = {} end #-------------------------------------------------------------------------- # alias method: skill_conditions_met? #-------------------------------------------------------------------------- alias game_battlerbase_skill_conditions_met_srs skill_conditions_met? def skill_conditions_met?(skill) return false if skill_restriction?(skill) return game_battlerbase_skill_conditions_met_srs(skill) end #-------------------------------------------------------------------------- # alias method: pay_skill_cost #-------------------------------------------------------------------------- alias game_battlerbase_pay_skill_cost_srs pay_skill_cost def pay_skill_cost(skill) game_battlerbase_pay_skill_cost_srs(skill) pay_skill_cooldown(skill) end #-------------------------------------------------------------------------- # new method: skill_restriction? #-------------------------------------------------------------------------- def skill_restriction?(skill) if $game_party.in_battle return true if cooldown?(skill) > 0 return true if warmup?(skill) > $game_troop.turn_count return true if limit_restricted?(skill) end return true if switch_restricted?(skill) return true if restrict_eval?(skill) return false end #-------------------------------------------------------------------------- # new method: cooldown? #-------------------------------------------------------------------------- def cooldown?(skill) skill = skill.id if skill.is_a?(RPG::Skill) return @cooldown[skill].nil? ? 0 : @cooldown[skill] end #-------------------------------------------------------------------------- # new method: warmup?(skill) #-------------------------------------------------------------------------- def warmup?(skill) skill = skill.id if skill.is_a?(RPG::Skill) return [$data_skills[skill].warmup * wur, 0].max.to_i end #-------------------------------------------------------------------------- # new method: limit_restricted? #-------------------------------------------------------------------------- def limit_restricted?(skill) return false if skill.limited_uses <= 0 return times_used?(skill) >= skill.limited_uses end #-------------------------------------------------------------------------- # new method: times_used? #-------------------------------------------------------------------------- def times_used?(skill) skill = skill.id if skill.is_a?(RPG::Skill) return @times_used[skill].nil? ? 0 : @times_used[skill] end #-------------------------------------------------------------------------- # new method: update_times_used #-------------------------------------------------------------------------- def update_times_used(skill) skill = skill.id if skill.is_a?(RPG::Skill) reset_times_used if @times_used.nil? @times_used[skill] = 0 if @times_used[skill].nil? @times_used[skill] += 1 end #-------------------------------------------------------------------------- # new method: cdr #-------------------------------------------------------------------------- def cdr n = 1.0 if actor? n *= self.actor.cooldown_rate n *= self.class.cooldown_rate for equip in equips next if equip.nil? n *= equip.cooldown_rate end else n *= self.enemy.cooldown_rate if $imported["YEA-Doppelganger"] && !self.class.nil? n *= self.class.cooldown_rate end end for state in states next if state.nil? n *= state.cooldown_rate end return n end #-------------------------------------------------------------------------- # new method: pay_skill_cooldown #-------------------------------------------------------------------------- def pay_skill_cooldown(skill) return unless $game_party.in_battle skill = skill.id if skill.is_a?(RPG::Skill) set_cooldown(skill, $data_skills[skill].cooldown * cdr) end #-------------------------------------------------------------------------- # new method: set_cooldown #-------------------------------------------------------------------------- def set_cooldown(skill, amount = 0) return unless $game_party.in_battle skill = skill.id if skill.is_a?(RPG::Skill) @cooldown[skill] = [amount, 0].max.to_i end #-------------------------------------------------------------------------- # new method: cooldown_lock? #-------------------------------------------------------------------------- def cooldown_lock? if actor? return true if self.actor.cooldown_lock return true if self.class.cooldown_lock for equip in equips next if equip.nil? return true if equip.cooldown_lock end else return true if self.enemy.cooldown_lock end for state in states next if state.nil? return true if state.cooldown_lock end return false end #-------------------------------------------------------------------------- # new method: update_cooldowns #-------------------------------------------------------------------------- def update_cooldowns(amount = -1, stype_id = 0, skill_id = 0) return if cooldown_lock? reset_cooldowns if @cooldown.nil? data_array = skills + [1, 2] for skill in data_array skill = $data_skills[skill] if !skill.is_a?(RPG::Skill) next if stype_id != 0 && skill.stype_id != stype_id next if skill_id != 0 && skill.id != skill_id set_cooldown(skill, cooldown?(skill) + amount) end end #-------------------------------------------------------------------------- # new method: wur #-------------------------------------------------------------------------- def wur n = 1.0 if actor? n *= self.actor.warmup_rate n *= self.class.warmup_rate for equip in equips next if equip.nil? n *= equip.warmup_rate end else n *= self.enemy.warmup_rate if $imported["YEA-Doppelganger"] && !self.class.nil? n *= self.class.warmup_rate end end for state in states next if state.nil? n *= state.warmup_rate end return n end #-------------------------------------------------------------------------- # new method: switch_restricted? #-------------------------------------------------------------------------- def switch_restricted?(skill) return true if restrict_any_switch?(skill) return true if restrict_all_switch?(skill) return false end #-------------------------------------------------------------------------- # new method: restrict_any_switch? #-------------------------------------------------------------------------- def restrict_any_switch?(skill) for switch_id in skill.restrict_any_switch return true if $game_switches[switch_id] end return false end #-------------------------------------------------------------------------- # new method: restrict_all_switch? #-------------------------------------------------------------------------- def restrict_all_switch?(skill) return false if skill.restrict_all_switch == [] for switch_id in skill.restrict_all_switch return false unless $game_switches[switch_id] end return true end #-------------------------------------------------------------------------- # new method: restrict_eval? #-------------------------------------------------------------------------- def restrict_eval?(skill) return false if skill.restrict_eval == "" return eval(skill.restrict_eval) end end # Game_BattlerBase #============================================================================== # ¡ Game_Battler #============================================================================== class Game_Battler < Game_BattlerBase #-------------------------------------------------------------------------- # alias method: on_battle_start #-------------------------------------------------------------------------- alias game_battler_on_battle_start_srs on_battle_start def on_battle_start game_battler_on_battle_start_srs reset_cooldowns reset_times_used end #-------------------------------------------------------------------------- # alias method: on_battle_end #-------------------------------------------------------------------------- alias game_battler_on_battle_end_srs on_battle_end def on_battle_end game_battler_on_battle_end_srs reset_cooldowns reset_times_used end #-------------------------------------------------------------------------- # alias method: item_apply #-------------------------------------------------------------------------- alias game_battler_item_apply_srs item_apply def item_apply(user, item) game_battler_item_apply_srs(user, item) updated_limited_uses(user, item) end #-------------------------------------------------------------------------- # new method: updated_limited_uses #-------------------------------------------------------------------------- def updated_limited_uses(user, item) return unless $game_party.in_battle return if item.nil? return unless item.is_a?(RPG::Skill) user.update_times_used(item) end #-------------------------------------------------------------------------- # alias method: item_user_effect #-------------------------------------------------------------------------- alias game_battler_item_user_effect_srs item_user_effect def item_user_effect(user, item) game_battler_item_user_effect_srs(user, item) apply_cooldown_changes(user, item) end #-------------------------------------------------------------------------- # new method: apply_cooldown_changes #-------------------------------------------------------------------------- def apply_cooldown_changes(user, item) return unless $game_party.in_battle return if item.nil? #--- if item.change_cooldown != {} for key in item.change_cooldown stype_id = key[0] update_cooldowns(item.change_cooldown[stype_id], stype_id) end @result.success = true end #--- if item.skill_cooldown != {} for key in item.skill_cooldown skill_id = key[0] update_cooldowns(item.skill_cooldown[skill_id], 0, skill_id) end @result.success = true end end end # Game_Battler #============================================================================== # ¡ Game_Enemy #============================================================================== class Game_Enemy < Game_Battler #-------------------------------------------------------------------------- # new method: skills #-------------------------------------------------------------------------- def skills data = [] for action in enemy.actions next if data.include?(action.skill_id) data.push(action.skill_id) end return data end end # Game_Enemy #============================================================================== # ¡ Game_Unit #============================================================================== class Game_Unit #-------------------------------------------------------------------------- # new method: update_restrictions #-------------------------------------------------------------------------- def update_restrictions for member in members; member.update_cooldowns; end end end # Game_Unit #============================================================================== # ¡ Window_Base #============================================================================== class Window_Base < Window #-------------------------------------------------------------------------- # new methods: restrict_colours #-------------------------------------------------------------------------- def cooldown_colour; text_color(YEA::SKILL_RESTRICT::COOLDOWN_COLOUR); end; def warmup_colour; text_color(YEA::SKILL_RESTRICT::WARMUP_COLOUR); end; def limited_colour; text_color(YEA::SKILL_RESTRICT::LIMITED_COLOUR); end; end # Window_Base #============================================================================== # ¡ Window_SkillList #============================================================================== class Window_SkillList < Window_Selectable #-------------------------------------------------------------------------- # alias method: draw_item #-------------------------------------------------------------------------- alias window_skilllist_draw_item_srs draw_item def draw_item(index) if skill_restriction?(index) draw_skill_restriction(index) else window_skilllist_draw_item_srs(index) end end #-------------------------------------------------------------------------- # new method: skill_restriction? #-------------------------------------------------------------------------- def skill_restriction?(index) skill = @data[index] return false if @actor.nil? return @actor.skill_restriction?(skill) end #-------------------------------------------------------------------------- # new method: draw_item #-------------------------------------------------------------------------- def draw_skill_restriction(index) skill = @data[index] rect = item_rect(index) rect.width -= 4 draw_item_name(skill, rect.x, rect.y, enable?(skill)) if @actor.limit_restricted?(skill) draw_skill_limited(rect, skill) elsif @actor.cooldown?(skill) > 0 draw_skill_cooldown(rect, skill) elsif warmup_restriction?(skill) draw_skill_warmup(rect, skill) else draw_skill_cost(rect, skill) end end #-------------------------------------------------------------------------- # new method: draw_skill_limited #-------------------------------------------------------------------------- def draw_skill_limited(rect, skill) change_color(limited_colour, enable?(skill)) icon = Icon.limited if icon > 0 draw_icon(icon, rect.x + rect.width-24, rect.y, enable?(skill)) rect.width -= 24 end contents.font.size = YEA::SKILL_RESTRICT::LIMITED_SIZE text = YEA::SKILL_RESTRICT::LIMITED_TEXT draw_text(rect, text, 2) reset_font_settings end #-------------------------------------------------------------------------- # new method: draw_skill_cooldown #-------------------------------------------------------------------------- def draw_skill_cooldown(rect, skill) change_color(cooldown_colour, enable?(skill)) icon = Icon.cooldown if icon > 0 draw_icon(icon, rect.x + rect.width-24, rect.y, enable?(skill)) rect.width -= 24 end contents.font.size = YEA::SKILL_RESTRICT::COOLDOWN_SIZE value = @actor.cooldown?(skill) text = sprintf(YEA::SKILL_RESTRICT::COOLDOWN_SUFFIX, value.group) draw_text(rect, text, 2) reset_font_settings end #-------------------------------------------------------------------------- # new method: warmup_restriction? #-------------------------------------------------------------------------- def warmup_restriction?(skill) return false unless $game_party.in_battle return @actor.warmup?(skill) > $game_troop.turn_count end #-------------------------------------------------------------------------- # new method: draw_skill_warmup #-------------------------------------------------------------------------- def draw_skill_warmup(rect, skill) change_color(warmup_colour, enable?(skill)) icon = Icon.warmup if icon > 0 draw_icon(icon, rect.x + rect.width-24, rect.y, enable?(skill)) rect.width -= 24 end contents.font.size = YEA::SKILL_RESTRICT::WARMUP_SIZE value = @actor.warmup?(skill) - $game_troop.turn_count text = sprintf(YEA::SKILL_RESTRICT::WARMUP_SUFFIX, value.group) draw_text(rect, text, 2) reset_font_settings end end # Window_SkillList #============================================================================== # ¡ Scene_Battle #============================================================================== class Scene_Battle < Scene_Base #-------------------------------------------------------------------------- # alias method: turn_start #-------------------------------------------------------------------------- alias scene_battle_turn_start_srs turn_start def turn_start $game_party.update_restrictions $game_troop.update_restrictions scene_battle_turn_start_srs end end # Scene_Battle #============================================================================== # # ¥ End of File # #==============================================================================