JP2000296228A - Image processing display device for pachinko machine - Google Patents

Abstract

PROBLEM TO BE SOLVED: To display large images and shifts thereof without increasing load of a CPU. SOLUTION: This image processing display device 2 for a Pachinko game machine has a register 23 stored with a first table for describing minimum display unit image numbers and orders read from a CG memory 21 in accordance with game information, and a second table for describing display attributes such as a read top address, read area defining data, display position data per minimum display unit image number, image reading means 24, 26, 27 for generating corresponding image data from the CG memory 21 by adding the display attributes for the second table to the selected data read from the first table, and a display device 32.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to an image display device, and more particularly, to an image processing display device suitable for use in displaying a game machine such as a pachinko machine or a game machine.

[0002]

2. Description of the Related Art In recent years, gaming machines such as pachinko machines which use a liquid crystal display device or a CRT display device in a so-called accessory portion arranged at the center of a pachinko machine in order to improve game characteristics have become mainstream. ing. Competition among companies is how to change the image displayed on the liquid crystal display device or the CRT display device to make the game more interesting. Therefore, in recent pachinko machines, it is required to increase the number of images to be displayed on the liquid crystal display device or the CRT display device and to realize the movement of images (characters) in finer units.

Conventionally, in game machines and the like, in order to move a character in finer units, an image of each character is decomposed into 8 × 8 dot units or 16 × 16 dot units and stored in a CG memory. Has been used in accordance with the display priority, and written out on a display memory or directly output to a display device. An apparatus using the sprite drawing method is disclosed in
For example, the apparatus described in JP-A-358847 can be fried. Japanese Patent Application Laid-Open No. Hei 8-1 discloses an example in which this sprite drawing method is used for displaying a game machine such as a pachinko machine or a game machine.
There is an image display device of a gaming machine described in Japanese Patent No. 17409.

The principle of the sprite drawing method will be described with reference to FIG. The image of each character is stored in the CG memory 1 in 8 ×
An image (sprite) decomposed in units of 8 dots or 16 × 16 dots is stored in advance. The sprite corresponding to the display image is read out from the CG memory in accordance with the display priority, and is sequentially written at a designated position on the display screen 2.

[0005]

However, in the conventional sprite drawing method, the size of one sprite is predetermined in units of 8 × 8 dots or 16 × 16 dots, and a large image (character) is displayed. In this case, it is necessary to prepare a sprite in which one large image is decomposed in units of 8 × 8 dots, and to continuously read out the sprite to reproduce one large image. At this time, the microprocessor (CPU) has to perform the setting process for each sprite, so that there is a problem that the load on the CPU increases.

SUMMARY OF THE INVENTION An object of the present invention is to provide an image display device of a gaming machine capable of displaying a large image or the like without increasing the load on the CPU.

[0007]

In order to achieve the above object, an image display device for a game machine according to the present invention renders image information on a display device provided on a game board in accordance with game information on a pachinko machine. In an image display device of a pachinko machine, a CG memory for storing display image data as bit data of an arbitrary size, and a CG memory in accordance with game information from the pachinko machine.
A first table in which the minimum display unit image numbers and the order of the images to be read from the memory are stored, a read start address on the CG memory for each minimum display unit image number to be displayed, and at least a read area range of 1 A second table storing display attributes including data defined in pixel units and display position data on a display device, and a second display unit image number read from the first table,
And a display device for reading the display attributes of the selected image with reference to the table and extracting the corresponding image data from the CG memory, and displaying the image data read from the CG memory by the image reading unit. .

As described above, since the range of the read area is defined in units of one pixel, even when rewriting a large image, it is sufficient to rewrite the set value to the table once for one image. The load can be reduced. The first table holds data specifying at least one of a minimum display unit image number and a group image number for displaying a plurality of minimum display unit images, and the second table has display attributes of the group as display attributes of the group. Data defining the minimum display unit image number belonging to the own group and display position data of the group are stored, and the image reading means reads the second table when the data read from the first table means a group image. , Read the display attributes of the individual minimum display unit image numbers that make up the group image, and add the minimum display position to the position obtained by adding the group display position as an offset to the display position of the individual minimum display unit image. By displaying the display unit images, the display positions of a plurality of images can be changed by a single operation, and the load on the CPU can be reduced. Reduce possible.

Further, a first area for storing display image data as bit data for each sprite of a predetermined size in the CG memory, and a free size determined by the start address and the size data for the display image data By providing a second area to be stored as an image, the conventional sprite drawing is applied to an image in which movement or the like is performed in small units, and a free area is specified for each pixel for a large image. The load on the CPU for one rendering designation can be reduced as a whole.

[0010]

Embodiments of the present invention will be described below in detail with reference to the drawings. FIG. 2 is a block diagram of a configuration of the image processing display device according to the embodiment of the present invention. FIG. 13 is a front view of a pachinko machine to which the image processing display device of FIG. 2 is attached. In FIG. 13, the pachinko machine includes an outer frame 1 for installation on an island of a pachinko parlor, a front frame 2 is attached to the front of the outer frame 1 so as to be openable and closable, and a metal frame 3 is provided on an inner peripheral edge of the front frame 2. A glass frame 4 is fixed in the metal frame 3 so as to be openable and closable by a hinge (not shown). A transparent glass 5 is fitted in the glass frame 4 so as to be fitted. An upper plate set 6 is attached.

A handle grip 8 and a lower plate set 9 of the hitting ball firing device are assembled to the lower edge of the front frame 2, and a game board 40 is mounted inside the front frame 2 so as to face the glass 5. You. An image display device having a liquid crystal color panel or a CRT is attached to the center of the game board 40, and a band 41, a game nail 42, a lamp windmill 43, and a windmill 4 are provided on a portion of the game board 40 located around the image display device.
4, starting winning opening 45, 46, winning opening 47, opening and closing body 48,
And a variable winning prize ball device (attacker) 49 having the above and an out port 60 are provided. Therefore, in this pachinko machine, when a game ball (not shown) is placed in the upper plate set 6 and the handle grip 8 is rotated in one direction, the firing device (not shown) causes the ball to be transferred from the upper plate set 6 to the band 41 one by one. Fire in. The fired game ball is guided along the band 41 above the game area in the band 41, and the upward thrust of the game ball becomes smaller than the gravity of the game ball, so that the game ball moves down the game area. The game nail 42, the ramp windmill 43, or the windmill 4
4 or the like, the ball enters the starting winning holes 45 and 46 to move the image display device, or enters the winning hole 47 to serve as a constant supply ball for supplying a constant number of game balls to the upper plate set 6 and supplying them as balls. The game balls that did not enter the start winning openings 45 and 46 or the winning opening 47 enter the out opening 60 and become out balls. Further, when the image display device displays a big hit by a combination of stop symbols after the variable display operation, the opening / closing plate 48 of the variable winning ball device 49 opens and closes, and becomes a hit ball against a game ball hit into the game area. The probability increases. The opening / closing operation of this variable winning prize ball device 49, the constant supply operation by winning the winning opening 47, the blinking of the lamp windmill 43, and the like are controlled by the game control device 28 shown in FIG.

Referring to FIG. 2, the game control device 28 and the image processing and display device 2 will be described in detail. . The game control device 28 is configured by a microcomputer that operates according to a preset program, and sends various game information such as game start information, scroll information, reach information, jackpot information, and probability variation information to the image processing display device 2. Output.

The rotation of the handle grip 8 is detected by the sensor 3.
1a, which is used as a game start detection signal. When the control device 28 receives the game start detection signal, a series of operations is started. The game ball hit by the player is the starting winning opening 4
When the game control device 28 receives a prize detection signal, the game control device 28 displays, for example, images of three rotating slots on the image processing display device 2 according to a program. Instruct
Each slot is sequentially stopped by stop symbol combination determination means using random numbers (not shown) built in the game control device 28. At this time, when the symbols of the two slots are aligned, a reach state is established, and the reach state is controlled. Subsequently, the remaining one slot is rotated, and when three symbols are aligned, a big hit (bingo) process is performed. Finally 3
When the three patterns are not aligned, a removal process is performed. In the jackpot process, the open / close plate 48 of the variable winning device 49 is kept open at a predetermined time, and a jackpot is displayed. In the losing process, a losing display is performed with the open / close plate 48 of the variable winning device 49 closed. The jackpot display and the loss display are processes for displaying an image prepared in advance using the display screen of the image processing display device 2 that has displayed images of three rotating slots.

Next, the image display control unit 20, which is a main component of the image processing and display device 2, will be described. 2, the image display control unit 20 includes a CG memory 21, a CPU interface 22, a register 23, an address generation unit 24,
Synchronous signal generator 27, image data output unit 26, CPU2
9, a program memory 30, and a register 23 includes a priority register 23a and an attribute register 2
3b.

The image data output unit 26 has an output line buffer 26a, and image data from the CG memory 21 is sequentially written into the output line buffer 26a, and read out according to a display clock from a synchronization signal generation unit 27.
It is supplied to a liquid crystal display or CRT 32. In practice, a plurality of (for example, two) line buffers are prepared as the output line buffer 26a and are alternately used for writing and reading.

The CPU 29 in the image processing and display device 2 has a CP
The display image setting value is written to the priority register 23a and the attribute register 23b through the U interface 22 every time the image is rewritten. A unit image number (a sprite number, a group number, and a family number in the present embodiment) is written into the priority register 23a at a position corresponding to the display priority. Priority 0 is the image which has the lowest display priority and is displayed first. Display attributes such as sprite images and groups described later are written in the attribute register 23b.

In the image processing display device 2, there is a program memory 30 storing a program in addition to the CPU 29.
All operations are performed according to the program read from the program memory 30. In FIG. 2, circuits for changing pallets, color modes and the like are not shown for simplicity of explanation, but many circuits other than those shown in the figure are further provided in actual circuits. Needless to say.

FIG. 3 shows the relationship between the data in the CG memory 21 and the display screen. Lots of image data (called sprites)
Are written in the CG memory 21 in advance. FIG. 4 shows an example of the priority register 23a. In FIG. 4, it is assumed that the sprite 92 (SP92) has the highest display priority and the sprite sprite 1 (SP1) has the lowest priority. Since images with lower priorities are displayed earlier, images with higher priorities are redrawn on the upper surface of the overlapping portion as shown in FIG. 3, and some of the images drawn earlier with lower priorities are later displayed. The image is partially hidden by the drawn image having the higher priority.

In this embodiment, each image is shown in FIG.
Are classified into three layers as shown in FIG. The lowermost sprites 0 to 95 indicate individual sprite images. The sprite images are grouped for each of a plurality of sprite images to form a group that is a higher hierarchy. Sprites 0-3 are the first group 0
Is composed. A sprite belonging to a group is expressed as an absolute position on the screen when the display position on the display screen is a single sprite, but is expressed as a relative position to the group display position. Therefore, when the group is moved, that is, when the group display position is rewritten, the display positions of all sprites belonging to the group are changed, and the group can be moved.

Each group is further grouped into a plurality of groups to form a higher-level group (herein referred to as "family"). The display position of the group belonging to the family is similarly expressed as a relative position with respect to the family display position. Therefore, if the family is moved, that is, if the head address of the family is rewritten, the display positions of all the groups belonging to the family are changed, and accordingly, the display positions of the sprites belonging to the group are also changed, so that the family is changed. Can be moved.

In the example of FIG. 4, sprites SP that are operated independently are described alone. Similarly, the group does not necessarily have to belong to the family FM, and can be described and drawn as an independent group GR. In FIG. 5, a sprite in which a symbol “x” is attached on a line connecting the group number and the sprite number is disconnected from the group, and is treated as a single sprite. Whether they are linked or independent is described in an attribute register 23b described later. In FIG. 5, the relationship between the family number and the group number is the same.

Next, the data structure of the attribute register 23b that defines an image or the like hierarchically represented in this manner will be described. FIG. 6 shows the data structure of the attribute register 23b. First, the setting value data written in the attribute register 23b in the case of a sprite is shown in FIG.
As shown in (A), (1) the read start address on the CG memory 21 (2) data indicating the size of the area on the CG memory 21 (horizontal direction, vertical direction) (3) display on the screen Position data (horizontal position, vertical position).

Here, data (horizontal direction, vertical direction) indicating the size of the area of the sprite on the CG memory 21
Is represented by the actual number of dots, such as 16 × 16 in FIG. 6, the actual set value data written in the attribute register 23b is “00” representing 8 × 8, 16 × 16
“01” representing 16; “10” representing 32 × 32;
One of four sizes is designated by two bits, such as “11” representing × 48.

Next, the set value data written in the attribute register 23b in the case of a group is shown in FIG.
(1) Group attribute (sprite number belonging to itself) (2) Display position data (horizontal position, vertical position) on the screen.

Next, the set value data written in the attribute register 23b for the family is shown in FIG.
As shown in (C), (1) Family attribute (group number belonging to oneself) (2) Display position data (horizontal position, vertical position) on the screen.

Here, the display position data on the screen is the sprite head position in the case of a sprite, the group display head position in the case of a group assuming the entire group as one window, and the family display head position in the case of a family. Become. Next, the operation will be described. CPU 29 is CP
The set value data of the display image is written to the priority register 23a and the attribute register 23b every time the display image is changed via the U interface 22.

The data of priority 0, that is, the image with the lowest display priority, is read from the priority register 23a. In the example of FIG. 4, sprite 1 is read out as data of priority 0. The display attribute of the sprite 1 is read from the attribute register 23b. The display attributes of the sprite 1 are as follows: (1) Read address on the CG memory 21 = “10” (2) Data indicating the size of the area on the CG memory 21 = 16 × 16 (3) Display position data on the screen = (150,200). The address generation unit 24 outputs the output line buffer 2
In accordance with the write timing to 6a, the address corresponding to the number of lines and the address corresponding to the position on the line are sequentially added to the start address = "10" on the CG memory 21 and read to the CG memory 21. Supply the address. Since the timing of writing to the output line buffer 26a is determined according to the display position data on the screen, the CG memory 21 is set at such a timing that the display start position of the sprite 1 on the screen becomes (150, 200). Data is read from the output line buffer 26
a.

In the case of a sprite belonging to a group or a family, an offset value corresponding to the sprite is added to the display position data on the screen to adjust the writing timing. However, this sprite 1 is a single sprite that does not belong to a group or the like. Therefore, the address generation unit 24 performs reading from the CG memory 21 and writing to the output line buffer 26a without considering the offset value.

Next, the data of priority 1 is read from the priority register 23a. This image is group 0 in the example of FIG. 4, and its display attribute is (1) group attribute = SP0, SP2, SP3 (2) display position data (2, 10) on the screen. Three sprite SPs that belong
0, SP2, and SP3 are displayed.

The display attribute of the sprite 0 (SP0) in the attribute register 23b is as follows: (1) Read address on the CG memory 21 = “0” (2) Data indicating the size of the area on the CG memory 21 = 8 × 8 (3) Since the display position data on the screen = (12, 200), in order to display the sprite 0, the selector 25 determines the display start position of the group 0 from the display attribute of the group 0 of the attribute register 23b. This is read and output as an offset value (2, 10). The address generation unit 24 determines the display position of the sprite 0 (12, 2
00) to the display position (14, 210) obtained by adding the offset value (2, 10) to the display position of sprite 0.
At the timing synchronized with the write timing of the output line buffer 26a of the image data output unit 26, the CG memory 2
A continuous read address of sprite 0 is output with the read start address on “1” = “0” as a read start address, and image data is output from the CG memory 21.

Similarly, the display attribute of the sprite 2 (SP2) is as follows: (1) Start address on the CG memory 21 = “30” (2) Data indicating the size of the area on the CG memory 21 = 8 × 8 (3 ) Since the display position data on the screen = (111, 300), in order to display the sprite 2, the display start position of the group 0 is read from the display attribute of the group 0 of the attribute register 23b, and this is set as the offset value. Output as (2,10). Address generation unit 24
Is the display position (11) obtained by adding the offset value (2, 10) to the display position (111, 300) of the sprite 2.
(3, 310) as the display position of the sprite 2 and the read start address = "30" on the CG memory 21 at the timing synchronized with the write timing of the output line buffer 26a of the image data output unit 26 as the read start address. A continuous read address is output, and image data is output from the CG memory 21.

Similarly, the sprite 3 is displayed at the display position to which the offset value (2, 10) is added. Next, from the priority register 23a, the priority 2
Is read out. This image is sprite 0 in the example of FIG. The splay 0 is the same sprite as that drawn in the previous group 0, but here, drawing as a single sprite is required.

The display attributes are as follows: (1) Read start address on CG memory 21 =
“0” (2) Data indicating the size of the area on the CG memory 21 = 8 × 8 (3) Display position data on the screen = (12,200) Since the display is performed according to this attribute.

In the same manner, images having higher priorities are sequentially displayed, and a final image is formed on the screen of the display device. As for the family, for example, since the data of the priority 6 of the priority register 23a indicates the family 1 (FM1), the display attribute of the family 1 is referred from the attribute register 23b.
Groups 4, 5, 6, and 7 are determined to be groups belonging to this family. Therefore, the display attributes of the sprites belonging to the groups 4, 5, 6, and 7 are read from the attribute register 23b, and the display destination position (30, 20) of this family is set in the display destination position of each group.
Is displayed as an offset value using the value obtained by adding.

According to the present embodiment, when a plurality of sprite images are combined and displayed, the processing of the display position can be performed collectively as a group or a family, so that the load on the CPU can be reduced as a whole. For example, in a case where nine sprite images are taken as one image group and moved as a whole, and only one sprite image in the group is replaced, the group head address is rewritten and the group attribute of the two sprites to be replaced is simply rewritten. Thus, the load on the CPU is much smaller than in the case where the display position data on the screen for all nine plus one change sprite images is rewritten.

FIG. 7 shows an example of an actual display image. Considering a case in which three helicopters are displayed on a helicopter in a continuous manner as shown in FIG. 7, the parts constituting these images are divided into 16 × 16 bit images as shown in FIG. Stored on the CG memory 21. In FIG. 8, each sprite is represented by a matrix of (horizontal axis letters, vertical axis numbers), and each sprite is 16 × 16.
It is represented by pit pixels. For example, the body of a helicopter is (B, 1), (B, 2), (C, 1), (C, 2),
It is configured by combining six sprites (D, 1) and (E, 1). The helicopter shown in FIG. 7A has these six sprites and the main rotors of (C, 3) and (D, 3).
It is completed by combining the (C, 4) sub-rotor. Further, the operator is completed by combining (B, 3) and (B, 4).

When changing from FIG. 7 (A) to FIG. 7 (B), the helicopter has main rotors (C, 3), (D,
From (3) to (E, 3), (F, 3), the sub-rotor is (C,
4) is changed to (D, 4), and the pirate becomes (B,
3) and (B, 4) are deleted, and the pilots (B, 3) and (B, 5) are drawn and rewritten in the helicopter cockpit. When changing from FIG. 7 (B) to FIG. 7 (C), the helicopter moves in parallel and moves to the upper left, and a new cloud image is displayed. In such a case, conventionally, to move the main body of the helicopter (B, 1),
(B, 2), (C, 1), (C, 2), (D, 1),
9 of (E, 1), (E, 3), (F, 3), (D, 4)
In order to redisplay the two sprites and the pilots (B, 3) and (B, 5) at different display positions, all nine attribute registers of the sprite shown in FIG. 6A must be rewritten. In the present invention, the display position of the group shown in FIG.
In the attribute register of the sprite shown in (A), only the same register as the previous one needs to be written, and the load on the CPU is reduced.

Next, a second embodiment of the present invention will be described. In the above embodiment, the size term of the attribute register of the sprite shown in FIG.
One of the four sizes represented by two bits “01”, “10”, and “11” is designated, but in the second embodiment, the size is specified on the CG memory. The image stored in advance is not a fixed size as in the case of a sprite, but is stored as an image having a size corresponding to the size of the display image, and the read start address and the size in the X and Y directions are stored. By specifying the size, data of a data amount corresponding to the size of the image is continuously read.
Therefore, the term of the size of the applicate register of the sprite shown in FIG. 6A is not a value coded in 2 bits but an actual number of dots (60 dots × 35 dots, etc.).
Is written.

FIG. 9 is a conceptual diagram on a CG memory according to the second embodiment of the present invention. This CG memory is different from the first embodiment in that addresses are not blocked (dotted lines in the figure are for easy understanding in comparison with FIG. It does not indicate such a block address.) 0 from upper left to lower right
Addresses from 00000 to FFFFFF are assigned for each pixel. The display image is stored therein for each display unit as shown in the figure, and at the time of drawing, the readout start address and the size (1 bit unit) of the cutout image are designated and output. FIG. 10 shows an example of the attribute register. In the present embodiment, one display unit is referred to as a window (WIN) to distinguish it from the first embodiment. Window 0 (WI
N0) is a window having a head address 3920 (a readout address of a pixel indicated by a in FIG. 9) and a size of 60 dots × 35 dots, which is a size for cutting out all the images of the helicopter in FIG.

Since the CPU only needs to specify the window attributes to draw one helicopter, the load is reduced as compared with the case where the attributes of nine sprites are specified by the sprite method. When drawing a picture of a rotating rotor, as shown in FIG. 10B, the read start position of the window for cutting out the image of the helicopter is set from the position below the rotor (the read address of the pixel indicated by the symbol b in FIG. 9). Window WIN0
〓, and the window of the rotating rotor (WIN
If 3) is drawn as the same group, only two windows need to be specified, so that the change can be easily made.

Next, a third embodiment of the present invention will be described. In the third embodiment, the area for storing the fixed size sprite image described in the first embodiment on the CG memory and the free size image described in the second embodiment are stored in the CG memory. It is provided with a window storage area capable of storing. FIG. 11 shows the configuration of the CG memory of the present embodiment. In the figure, blocks (A, 0) to (G, 3) are areas for storing sprite images, that is, sprite areas 1
00, the blocks (A, 4) to (G, 6) are a window storage area 200 having a free drawing area. (A, 0) and (B, 0) are included in the sprite area 100.
Alternatively, a component-like image that is frequently rewritten in order to represent a motion, such as (A, 1) to (A, 3), is stored, and the window storage area 200 is large enough to represent a combination of a plurality of sprite images. Store the image. At this time, the term of the size of the read area of the attribute register of the image displaying the sprite is represented by two bits of “00”, “01”, “10”, and “11” as shown in FIG. The size term of the attribute register when displaying a window image is represented by the actual number of dots as shown in FIG.

The image read from the window storage area 200 and the image read from the sprite area 100 when storing in the attribute register are shown in FIG.
If the data is grouped and stored as shown in FIG. 2C, high-speed drawing and movement can be easily performed. In the above embodiment, FIG.
As described above, the sprite image storage area and the window storage area that can store images of any size are set separately.
If the size of the read area of the attribute register is a 2-byte code, the address of the size corresponding to the code is automatically and sequentially output. If it is represented, the same image can be treated as both a sprite image and a window image if the address generation unit 24 is configured to sequentially generate addresses corresponding to the size. The sprite image is suitable for displaying frequently rewritten images because the data setting is represented by a read start address and a 2-byte size code, and the window image is suitable for rewriting a large image at a time. With such a configuration, the same image can be displayed in an optimal display method according to the case, so that the load on the CPU can be further reduced.

[0043]

As described above, according to the present invention, it is possible to provide an image processing and display device capable of displaying a large image or the like without increasing the load on the CPU. Further, according to the present invention, it is possible to provide an image display device capable of moving and displaying a large image or the like without increasing the load on the CPU.

[Brief description of the drawings]

FIG. 1 is an explanatory diagram illustrating a conventional sprite drawing method.

FIG. 2 is a block diagram illustrating a configuration of an image processing display device according to the embodiment of the present invention.

FIG. 3 is an explanatory diagram illustrating an operation of the image processing display device according to the first embodiment of the present invention.

FIG. 4 is an explanatory diagram illustrating an example of a priority register of the image processing display device according to the first embodiment of this invention;

FIG. 5 is an explanatory diagram showing a relationship among a family, a group, and a sprite of the image processing display device according to the first embodiment of the present invention.

FIG. 6 is an explanatory diagram illustrating an example of an attribute register of the image processing display device according to the first embodiment of the present invention.

FIG. 7 is an explanatory diagram illustrating an actual drawing example of the image processing display device according to the first embodiment of the present invention.

FIG. 8 is an explanatory diagram illustrating an example of a CG memory of the image processing display device according to the first embodiment of the present invention.

FIG. 9 is an explanatory diagram illustrating an example of a CG memory of the image processing display device according to the second embodiment of this invention.

FIG. 10 is an explanatory diagram illustrating an example of an attribute register of the image processing display device according to the second embodiment of this invention.

FIG. 11 is an explanatory diagram illustrating an example of a CG memory of an image processing display device according to a third embodiment of the present invention.

FIG. 12 is an explanatory diagram showing an example of an attribute register of the image processing display device according to the third embodiment of the present invention.

13 is a front view of a pachinko machine to which the image display processing device of FIG. 2 is attached.

[Explanation of symbols]

 Reference Signs List 21 CG memory 22 CPU interface 23a Priority register 23b Attribute register 24 Address generation unit 26 Image data output unit 27 Synchronization signal generation unit 28 Game machine control unit 32 Liquid crystal or CRT display device

 ──────────────────────────────────────────────────続 き Continued on the front page F term (reference) 2C088 AA36 EB55 5B069 AA16 BA03 BC07 DD15 DD16 DD17 FA03 5C082 AA06 BA12 BA43 BB13 BB42 BB53 BD01 BD02 CA52 CA55 DA22 DA42 DA73 DA86 DA87 MM02 MM05

Claims (10)

[Claims] 1. An image processing and display device for a pachinko machine that draws image information extracted from a memory on a display device provided on a pachinko game board in accordance with game information for the pachinko machine. CG memory for storing bit data of the same, a first table storing the minimum display unit image number and the order of images read from the CG memory in accordance with game information from the pachinko machine, and the minimum display unit image to be displayed A second table storing, for each number, a read start address on the CG memory, data defining at least a range of a read area in units of one pixel, and display attributes including display position data on a display device; Displaying the image selected with reference to the second table for the minimum display unit image number read from the first table; A pachinko machine comprising: an image reading unit that reads an attribute and retrieves corresponding image data from the CG memory; and a display device that displays the image data read from the CG memory by the image reading unit. Image processing display device. 2. The data according to claim 1, wherein the first table holds data defining at least one of the minimum display unit image number and a group image number for displaying a plurality of the minimum display unit images. In the second table, data defining the minimum display unit image number belonging to the own group and display unit data of the group are stored as display attributes of the group, and the image reading means reads from the first table. When the obtained data means the group image, the display attribute of each minimum display unit image number constituting the group image is read out by referring to the second table, and the display position of each minimum display unit image is read. Display the minimum display unit image at a position obtained by adding the display position of the group as an offset amount. Image processing and displaying apparatus of the pachinko machine to be. 3. The first CG memory according to claim 1, wherein the CG memory stores display image data as bit data for each sprite having a predetermined size.
An image processing and display device for a pachinko machine, comprising a second area for storing display image data as an image of a free size determined by a start address and size data. 4. The display image according to claim 1, wherein the second table has a display image having data of a predetermined sprite size as a display attribute as data defining a range of the readout area. An image processing and display apparatus for a pachinko machine, characterized by including data of both images of a display image having size data determined for each pixel as a display attribute. 5. A CG memory for storing display image data as bit data, a read start address on the CG memory, data for arbitrarily defining a range of a read area in units of one pixel, and a display position on a display device. A table for storing display image attribute data including data for each display image, image reading means for selectively extracting image data from the CG memory according to the display image attribute data read from the table, and reading from the table Image data output means for outputting image data to a display device in accordance with the obtained display position data, and an image processing display device for a pachinko machine. 6. The image of a pachinko machine according to claim 5, wherein the data defining the range of the readout area stored in the table includes data specifying a readout area having a different size for each display image. Processing display device. 7. The data according to claim 5, wherein the data defining the range of the readout area stored in the table is a display image in units of a readout area of a predetermined size and a readout for each display image. An image processing and display device for a pachinko machine, characterized by storing both display images for arbitrarily specifying the size of an area in units of one pixel. 8. The image processing and display device for a pachinko machine according to claim 5, wherein the display image attribute data stored in the table stores display attributes of a plurality of display images as a group. 9. The display device according to claim 5, wherein the display position of each display image in which the display attributes of the display images are stored as a group is determined by adding the display position of the group to the display position of each display image. Characterized image processing and display device for pachinko machines. 10. An image processing and displaying apparatus for a pachinko machine according to claim 8, wherein said group further stores display attributes of a display image for each of a plurality of groups.