INSERT_TITLE| Windows Key Binding | macOS Key Binding | Scope | Description | |
|---|---|---|---|---|
| "+winKeyCombo+" | \n" - - # MacOS key combination - macKeyCombo = replaceMacChars(row[2]) - tableRow += "\t"+macKeyCombo+" | \n" - - # Category/Scope/Section - previousSection = section - tableRow += "\t"+section+" | \n" - - # Description - if description: - tableRow += "\t"+description+" | \n" - else: - tableRow += "\t"+name+" *** | \n" - - tableRow += "
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| F3 | -F3 | -AIAssistant | -- |
| SHIFT+F3 | -SHIFT+F3 | -AIAssistant | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| BackSpace | -Delete | -Anim Curve Editor | -- |
| Escape | -Escape | -Anim Curve Editor | -- |
| CTRL+W | -CTRL+W | -Anim Curve Editor | -- |
| CTRL+A | -CMD+A | -Anim Curve Editor | -- |
| CTRL+R | -CMD+R | -Anim Curve Editor | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| CTRL+Right Bracket | -CTRL+Right Bracket | -Asset Browser | -- |
| CTRL+Left Bracket | -CTRL+Left Bracket | -Asset Browser | -- |
| CTRL+SHIFT+Right Bracket | -CTRL+SHIFT+Right Bracket | -Asset Browser | -- |
| CTRL+SHIFT+Left Bracket | -CTRL+SHIFT+Left Bracket | -Asset Browser | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| CTRL+Insert | -CTRL+Insert | -Errors | -- |
| CTRL+SHIFT+A | -CTRL+SHIFT+A | -Errors | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| SHIFT+F11 | -SHIFT+F11 | -Feather | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| CTRL+A | -CMD+A | -Font Editor | -- |
| CTRL+D | -CMD+D | -Font Editor | -- |
| CTRL+SHIFT+O | -CMD+SHIFT+O | -Font Editor | -- |
| CTRL+R | -CMD+R | -Font Editor | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| Tab | -Tab, | -Global | -- |
| SHIFT+Tab | -SHIFT+Tab, | -Global | -- |
| Enter | -Enter | -Global | -- |
| CTRL+Z | -CMD+Z | -Global | -- |
| CTRL+Y | -CMD+Y | -Global | -- |
| ALT+F4 | -CMD+Q | -Global | -- |
| CTRL+SHIFT+S | -CMD+SHIFT+S | -Global | -- |
| CTRL+E | -CMD+E | -Global | -- |
| SHIFT+F12 | -SHIFT+F12 | -Global | -- |
| CTRL+W | -CMD+W | -Global | -- |
| CTRL+Enter | -CMD+Enter | -Global | -- |
| CTRL+Equals | -CMD+Equals | -Global | -- |
| CTRL+Minus | -CMD+Minus | -Global | -- |
| CTRL+ALT+Enter | -CMD+ALT+Enter | -Global | -- |
| CTRL+ALT+Up | -CMD+ALT+Up | -Global | -- |
| CTRL+ALT+Down | -CMD+ALT+Down | -Global | -- |
| CTRL+ALT+Left | -CMD+ALT+Left | -Global | -- |
| CTRL+ALT+Right | -CMD+ALT+Right | -Global | -- |
| CTRL+ALT+Up+Left | -CMD+ALT+Up+Left | -Global | -- |
| CTRL+ALT+Down+Left | -CMD+ALT+Down+Left | -Global | -- |
| CTRL+ALT+Up+Right | -CMD+ALT+Up+Right | -Global | -- |
| CTRL+ALT+Down+Right | -CMD+ALT+Down+Right | -Global | -- |
| F2 | -F2 | -Global | -- |
| Escape | -Escape | -Global | -- |
| CTRL+D | -CMD+D | -Global | -- |
| CTRL+X | -CMD+X | -Global | -- |
| CTRL+C | -CMD+C | -Global | -- |
| CTRL+V | -CMD+V | -Global | -- |
| CTRL+A | -CMD+A | -Global | -- |
| CTRL+K | -CMD+K | -Global | -- |
| CTRL+SHIFT+K | -CMD+SHIFT+K | -Global | -- |
| CTRL+PageUp | -CMD+PageUp | -Global | -- |
| CTRL+PageDown | -CMD+PageDown | -Global | -- |
| F7 | -F7 | -Global | -- |
| F8 | -F8 | -Global | -- |
| Delete | -Delete | -Global | -- |
| F5 | -F5 | -Global | -- |
| F11 | -CMD+SHIFT+I | -Global | -- |
| F10 | -CMD+SHIFT+O | -Global | -- |
| SHIFT+F11 | -CMD+SHIFT+U | -Global | -- |
| CTRL+SHIFT+P | -CMD+SHIFT+P | -Global | -- |
| CTRL+T | -CMD+T | -Global | -- |
| CTRL+Tab | -CTRL+Tab, | -Global | -- |
| F5 | -F5 | -Global | -- |
| F6 | -F6 | -Global | -- |
| CTRL+F7 | -CMD+F7 | -Global | -- |
| CTRL+F8 | -CMD+F8 | -Global | -- |
| - | CMD+SHIFT+V | -Global | -- |
| - | CMD+SHIFT+D | -Global | -- |
| - | CMD+SHIFT+M | -Global | -- |
| CTRL+SHIFT+F | -CMD+SHIFT+F | -Global | -- |
| CTRL+F | -CMD+F | -Global | -- |
| CTRL+H | -CMD+R | -Global | -- |
| CTRL+SHIFT+I | -CTRL+SHIFT+I | -Global | -- |
| CTRL+SHIFT+0 | -CMD+CTRL+0 | -Global | -- |
| CTRL+0 | -CMD+0 | -Global | -- |
| CTRL+SHIFT+1 | -CMD+CTRL+1 | -Global | -- |
| CTRL+1 | -CMD+1 | -Global | -- |
| CTRL+SHIFT+2 | -CMD+CTRL+2 | -Global | -- |
| CTRL+2 | -CMD+2 | -Global | -- |
| CTRL+SHIFT+3 | -CMD+CTRL+3 | -Global | -- |
| CTRL+3 | -CMD+3 | -Global | -- |
| CTRL+SHIFT+4 | -CMD+CTRL+4 | -Global | -- |
| CTRL+4 | -CMD+4 | -Global | -- |
| CTRL+SHIFT+5 | -CMD+CTRL+5 | -Global | -- |
| CTRL+5 | -CMD+5 | -Global | -- |
| CTRL+SHIFT+6 | -CMD+CTRL+6 | -Global | -- |
| CTRL+6 | -CMD+6 | -Global | -- |
| CTRL+SHIFT+7 | -CMD+CTRL+7 | -Global | -- |
| CTRL+7 | -CMD+7 | -Global | -- |
| CTRL+SHIFT+8 | -CMD+CTRL+8 | -Global | -- |
| CTRL+8 | -CMD+8 | -Global | -- |
| CTRL+SHIFT+9 | -CMD+CTRL+9 | -Global | -- |
| CTRL+9 | -CMD+9 | -Global | -- |
| SHIFT+O | -SHIFT+O | -Global | -- |
| CTRL+SHIFT+B | -CTRL+SHIFT+B | -Global | -- |
| CTRL+SHIFT+A | -CTRL+SHIFT+A | -Global | -- |
| F3 | -F3 | -Global | -- |
| SHIFT+F3 | -SHIFT+F3 | -Global | -- |
| CTRL+SHIFT+R | -CTRL+SHIFT+R | -Global | -- |
| CTRL+P | -CMD+P | -Global | -- |
| CTRL+R | -CMD+R | -Global | -- |
| X | -X | -Global | -- |
| Y | -Y | -Global | -- |
| CTRL+G | -CMD+G | -Global | -- |
| CTRL+Semicolon | -CTRL+Semicolon | -Global | -- |
| CTRL+ALT+SHIFT+Semicolon | -CTRL+ALT+SHIFT+Semicolon | -Global | -- |
| CTRL+SHIFT+Semicolon | -CTRL+SHIFT+Semicolon | -Global | -- |
| Space | -Space | -Global | -- |
| G | -G | -Global | -- |
| Left | -Left | -Global | -- |
| Right | -Right | -Global | -- |
| Up | -Up | -Global | -- |
| Down | -Down | -Global | -- |
| - | CMD+SHIFT+Q | -Global | -- |
| CTRL+N | -CMD+N | -Global | -- |
| CTRL+O | -CMD+O | -Global | -- |
| CTRL+S | -CMD+S | -Global | -- |
| ALT+J | -ALT+J | -Global | -- |
| ALT+E | -ALT+E | -Global | -- |
| ALT+F | -ALT+F | -Global | -- |
| ALT+N | -ALT+N | -Global | -- |
| ALT+O | -ALT+O | -Global | -- |
| ALT+P | -ALT+P | -Global | -- |
| ALT+R | -ALT+R | -Global | -- |
| ALT+C | -ALT+C | -Global | -- |
| ALT+G | -ALT+G | -Global | -- |
| ALT+A | -ALT+A | -Global | -- |
| ALT+U | -ALT+U | -Global | -- |
| ALT+S | -ALT+S | -Global | -- |
| ALT+B | -ALT+B | -Global | -- |
| ALT+T | -ALT+T | -Global | -- |
| ALT+K | -ALT+K | -Global | -- |
| CTRL+SHIFT+E | -CMD+SHIFT+E | -Global | -- |
| CTRL+Space | -CMD+Space | -Global | -- |
| CTRL+SHIFT+N | -CMD+SHIFT+N | -Global | -- |
| CTRL+SHIFT+E | -CMD+SHIFT+E | -Global | -- |
| CTRL+SHIFT+S | -CMD+SHIFT+S | -Global | -- |
| CTRL+F | -CMD+F | -Global | -- |
| CTRL+A | -CMD+A | -Global | -- |
| CTRL+C | -CMD+C | -Global | -- |
| PageDown | -PageDown | -Global | -- |
| PageUp | -PageUp | -Global | -- |
| F1 | -F1 | -Global | -- |
| F12 | -F12 | -Global | -- |
| CTRL | -CMD | -Global | -- |
| Space | -Space | -Global | -- |
| CTRL | -CMD | -Global | -- |
| SHIFT | -SHIFT | -Global | -- |
| ALT | -ALT | -Global | -- |
| CTRL | -CMD | -Global | -- |
| SHIFT | -SHIFT | -Global | -- |
| CTRL+Q | -CTRL+Q | -Global | -- |
| ALT+K | -ALT+K | -Global | -- |
| ALT+I | -ALT+I | -Global | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| Equals | -Equals | -Image Editor | -- |
| KeypadPlus | -KeypadPlus | -Image Editor | -- |
| Minus | -Minus | -Image Editor | -- |
| KeypadMinus | -KeypadMinus | -Image Editor | -- |
| Period | -Period | -Image Editor | -- |
| B | -B | -Image Editor | -- |
| 3 | -3 | -Image Editor | -- |
| Enter | -Enter | -Image Editor | -- |
| ALT+V | -ALT+V | -Image Editor | -- |
| ALT+H | -ALT+H | -Image Editor | -- |
| ALT+C | -ALT+C | -Image Editor | -- |
| ALT+F | -ALT+F | -Image Editor | -- |
| 2 | -2 | -Image Editor | -- |
| 1 | -1 | -Image Editor | -- |
| SHIFT+Delete | -SHIFT+Delete | -Image Editor | -- |
| CTRL+Insert | -CTRL+Insert | -Image Editor | -- |
| SHIFT+Insert | -SHIFT+Insert | -Image Editor | -- |
| CTRL+B | -CTRL+B | -Image Editor | -- |
| CTRL+I | -CTRL+I | -Image Editor | -- |
| SHIFT+A | -SHIFT+A | -Image Editor | -- |
| Insert | -Insert | -Image Editor | -- |
| BackSpace | -Delete | -Image Editor | -- |
| CTRL+SHIFT+A | -CMD+SHIFT+A | -Image Editor | -- |
| CTRL+I | -CMD+I | -Image Editor | -- |
| CTRL+I | -CMD+I | -Image Editor | -- |
| CTRL+SHIFT+A | -CMD+SHIFT+A | -Image Editor | -- |
| ALT+C | -ALT+C | -Image Editor | -- |
| ALT+F | -ALT+F | -Image Editor | -- |
| D | -D | -Image Editor | -- |
| E | -E | -Image Editor | -- |
| F | -F | -Image Editor | -- |
| H | -H | -Image Editor | -- |
| V | -V | -Image Editor | -- |
| L | -L | -Image Editor | -- |
| O | -O | -Image Editor | -- |
| R | -R | -Image Editor | -- |
| SHIFT+R | -SHIFT+R | -Image Editor | -- |
| C | -C | -Image Editor | -- |
| SHIFT+C | -SHIFT+C | -Image Editor | -- |
| S | -S | -Image Editor | -- |
| Q | -Q | -Image Editor | -- |
| W | -W | -Image Editor | -- |
| P | -P | -Image Editor | -- |
| SHIFT+P | -SHIFT+P | -Image Editor | -- |
| A | -A | -Image Editor | -- |
| U | -U | -Image Editor | -- |
| Z | -Z | -Image Editor | -- |
| M | -M | -Image Editor | -- |
| T | -T | -Image Editor | -- |
| CTRL | -CMD | -Image Editor | -- |
| SHIFT+Z | -SHIFT+Z | -Image Editor | -- |
| CTRL | -CMD | -Image Editor | -- |
| ALT | -ALT | -Image Editor | -- |
| SHIFT | -SHIFT | -Image Editor | -- |
| ALT | -ALT | -Image Editor | -- |
| SHIFT | -SHIFT | -Image Editor | -- |
| ALT | -ALT | -Image Editor | -- |
| ALT | -ALT | -Image Editor | -- |
| CTRL | -CTRL | -Image Editor | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| CTRL+SHIFT+F | -CMD+SHIFT+F | -Context Menu | -- |
| F1 | -F1 | -Context Menu | -- |
| 1 | -1 | -Context Menu | -- |
| 2 | -2 | -Context Menu | -- |
| 3 | -3 | -Context Menu | -- |
| 4 | -4 | -Context Menu | -- |
| 5 | -5 | -Context Menu | -- |
| 6 | -6 | -Context Menu | -- |
| 7 | -7 | -Context Menu | -- |
| 8 | -8 | -Context Menu | -- |
| 9 | -9 | -Context Menu | -- |
| 0 | -0 | -Context Menu | -- |
| C | -C | -Context Menu | -- |
| M | -M | -Context Menu | -- |
| R | -R | -Context Menu | -- |
| Del | -Del | -Context Menu | -- |
| F9 | -F9 | -Context Menu | -- |
| CTRL+P | -CTRL+P | -Context Menu | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| SHIFT+Insert | -SHIFT+Insert | -Object Editor | -- |
| CTRL+Insert | -CTRL+Insert | -Object Editor | -- |
| SHIFT+Delete | -SHIFT+Delete | -Object Editor | -- |
| CTRL+SHIFT+M | -CMD+SHIFT+M | -Object Editor | -- |
| CTRL+K | -CMD+K | -Object Editor | -- |
| CTRL+F | -CMD+F | -Object Editor | -- |
| CTRL+G | -CMD+G | -Object Editor | -- |
| CTRL+H | -CMD+H | -Object Editor | -- |
| CTRL+J | -CMD+J | -Object Editor | -- |
| CTRL+A | -CMD+A | -Object Editor | -- |
| CTRL+P | -CMD+P | -Object Editor | -- |
| CTRL+SHIFT+O | -CMD+SHIFT+O | -Object Editor | -- |
| CTRL+L | -CMD+L | -Object Editor | -- |
| CTRL+B | -CMD+B | -Object Editor | -- |
| CTRL+SHIFT+Y | -CMD+Y | -Object Editor | -- |
| CTRL+U | -CMD+U | -Object Editor | -- |
| CTRL+ALT+T | -CMD+ALT+T | -Object Editor | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| CTRL+SHIFT+O | -CMD+SHIFT+O | -Path Editor | -- |
| Left | -Left | -Path Editor | -- |
| Right | -Right | -Path Editor | -- |
| Up | -Up | -Path Editor | -- |
| Down | -Down | -Path Editor | -- |
| R | -R | -Path Editor | -- |
| T | -T | -Path Editor | -- |
| S | -S | -Path Editor | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| CTRL+ALT+I | -CMD+ALT+I | -Room Editor | -- |
| CTRL+ALT+L | -CMD+ALT+L | -Room Editor | -- |
| SHIFT+Delete | -SHIFT+Delete | -Room Editor | -- |
| CTRL+Insert | -CTRL+Insert | -Room Editor | -- |
| SHIFT+Insert | -SHIFT+Insert | -Room Editor | -- |
| SHIFT+X | -SHIFT+X | -Room Editor | -- |
| X | -X | -Room Editor | -- |
| SHIFT+Y | -SHIFT+Y | -Room Editor | -- |
| Y | -Y | -Room Editor | -- |
| CTRL+ALT+G | -CMD+ALT+G | -Room Editor | -- |
| CTRL+B | -CMD+B | -Room Editor | -- |
| CTRL+ALT+T | -CMD+ALT+T | -Room Editor | -- |
| CTRL+P | -CMD+P | -Room Editor | -- |
| CTRL+A | -CMD+A | -Room Editor | -- |
| CTRL+F | -CMD+F | -Room Editor | -- |
| CTRL | -CTRL | -Room Editor | -- |
| ALT | -ALT | -Room Editor | -- |
| P | -P | -Room Editor | -- |
| A | -A | -Room Editor | -- |
| Y | -Y | -Room Editor | -- |
| X | -X | -Room Editor | -- |
| E | -E | -Room Editor | -- |
| F | -F | -Room Editor | -- |
| I | -I | -Room Editor | -- |
| L | -L | -Room Editor | -- |
| D | -D | -Room Editor | -- |
| R | -R | -Room Editor | -- |
| Z | -Z | -Room Editor | -- |
| S | -S | -Room Editor | -- |
| CTRL+ALT+S | -CTRL+ALT+S | -Room Editor | -- |
| CTRL+E | -CTRL+E | -Room Editor | -- |
| Equals | -Equals | -Room Editor | -- |
| Minus | -Minus | -Room Editor | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| F7 | -F7 | -Sequence Editor | -- |
| F8 | -F8 | -Sequence Editor | -- |
| F9 | -F9 | -Sequence Editor | -- |
| F10 | -F10 | -Sequence Editor | -- |
| BackSpace | -Delete | -Sequence Editor | -- |
| Q | -Q | -Sequence Editor | -- |
| CTRL+SHIFT+Home | -CTRL+SHIFT+Home | -Sequence Editor | -- |
| CTRL+Home | -CTRL+Home | -Sequence Editor | -- |
| CTRL+ALT+P | -CTRL+ALT+P | -Sequence Editor | -- |
| ALT+SHIFT+Left | -ALT+SHIFT+Left | -Sequence Editor | -- |
| ALT+SHIFT+Right | -ALT+SHIFT+Right | -Sequence Editor | -- |
| ALT+Left | -ALT+Left | -Sequence Editor | -- |
| ALT+Right | -ALT+Right | -Sequence Editor | -- |
| CTRL+SHIFT+Left | -CTRL+SHIFT+Left | -Sequence Editor | -- |
| CTRL+SHIFT+Right | -CTRL+SHIFT+Right | -Sequence Editor | -- |
| CTRL+Left | -CTRL+Left | -Sequence Editor | -- |
| CTRL+Right | -CTRL+Right | -Sequence Editor | -- |
| SHIFT+Up | -SHIFT+Up | -Sequence Editor | -- |
| SHIFT+Down | -SHIFT+Down | -Sequence Editor | -- |
| SHIFT+Left | -SHIFT+Left | -Sequence Editor | -- |
| SHIFT+Right | -SHIFT+Right | -Sequence Editor | -- |
| Up | -Up | -Sequence Editor | -- |
| Down | -Down | -Sequence Editor | -- |
| Left | -Left | -Sequence Editor | -- |
| Right | -Right | -Sequence Editor | -- |
| Left Bracket | -Left Bracket | -Sequence Editor | -- |
| Right Bracket | -Right Bracket | -Sequence Editor | -- |
| CTRL+ALT+D | -CTRL+ALT+D | -Sequence Editor | -- |
| SHIFT+Right Bracket | -SHIFT+Right Bracket | -Sequence Editor | -- |
| SHIFT+Left Bracket | -SHIFT+Left Bracket | -Sequence Editor | -- |
| N | -N | -Sequence Editor | -- |
| M | -M | -Sequence Editor | -- |
| SHIFT+N | -SHIFT+N | -Sequence Editor | -- |
| SHIFT+M | -SHIFT+M | -Sequence Editor | -- |
| Home | -Home | -Sequence Editor | -- |
| End | -End | -Sequence Editor | -- |
| SHIFT+Home | -SHIFT+Home | -Sequence Editor | -- |
| SHIFT+End | -SHIFT+End | -Sequence Editor | -- |
| U | -U | -Sequence Editor | -- |
| CTRL+U | -CTRL+U | -Sequence Editor | -- |
| ALT+Up | -ALT+Up | -Sequence Editor | -- |
| ALT+Down | -ALT+Down | -Sequence Editor | -- |
| CTRL+ALT+Up | -CTRL+ALT+Up | -Sequence Editor | -- |
| CTRL+ALT+Down | -CTRL+ALT+Down | -Sequence Editor | -- |
| CTRL+M | -CTRL+M | -Sequence Editor | -- |
| ALT+G | -ALT+G | -Sequence Editor | -- |
| CTRL+8 | -CTRL+8 | -Sequence Editor | -- |
| CTRL+9 | -CTRL+9 | -Sequence Editor | -- |
| SHIFT+8 | -SHIFT+8 | -Sequence Editor | -- |
| SHIFT+9 | -SHIFT+9 | -Sequence Editor | -- |
| T | -T | -Sequence Editor | -- |
| S | -S | -Sequence Editor | -- |
| R | -R | -Sequence Editor | -- |
| Y | -Y | -Sequence Editor | -- |
| CTRL+R | -CTRL+R | -Sequence Editor | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| CTRL+SHIFT+O | -CMD+SHIFT+O | -Sound Editor | -- |
| CTRL+SHIFT+M | -CMD+SHIFT+M | -Sound Editor | -- |
| M | -M | -Sound Editor | -- |
| Space | -Space | -Sound Editor | -- |
| L | -L | -Sound Editor | -- |
| R | -R | -Sound Editor | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| M | -M | -Sound Mixer | -- |
| Space | -Space | -Sound Mixer | -- |
| L | -L | -Sound Mixer | -- |
| R | -R | -Sound Mixer | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| CTRL+8 | -CTRL+8 | -Sprite Editor | -- |
| SHIFT+A | -SHIFT+A | -Sprite Editor | -- |
| Insert | -Insert | -Sprite Editor | -- |
| CTRL+Insert | -CTRL+Insert | -Sprite Editor | -- |
| SHIFT+Insert | -SHIFT+Insert | -Sprite Editor | -- |
| SHIFT+Delete | -SHIFT+Delete | -Sprite Editor | -- |
| CTRL+I | -CMD+I | -Sprite Editor | -- |
| CTRL+R | -CMD+R | -Sprite Editor | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| CTRL+Insert | -CTRL+Insert | -Errors | -- |
| CTRL+SHIFT+A | -CTRL+SHIFT+A | -Errors | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| Left | -Left | -Text Editor | -- |
| Right | -Right | -Text Editor | -- |
| Up | -Up | -Text Editor | -- |
| Down | -Down | -Text Editor | -- |
| SHIFT+Left | -SHIFT+Left | -Text Editor | -- |
| SHIFT+Right | -SHIFT+Right | -Text Editor | -- |
| SHIFT+Up | -SHIFT+Up | -Text Editor | -- |
| SHIFT+Down | -SHIFT+Down | -Text Editor | -- |
| ALT+SHIFT+Up | -ALT+SHIFT+Up | -Text Editor | -- |
| ALT+SHIFT+Down | -ALT+SHIFT+Down | -Text Editor | -- |
| PageUp | -PageUp | -Text Editor | -- |
| PageDown | -PageDown | -Text Editor | -- |
| SHIFT+PageUp | -SHIFT+PageUp | -Text Editor | -- |
| SHIFT+PageDown | -SHIFT+PageDown | -Text Editor | -- |
| CTRL+Up | -CTRL+PageUp | -Text Editor | -- |
| CTRL+Down | -CTRL+PageDown | -Text Editor | -- |
| CTRL+SHIFT+Up | -CTRL+SHIFT+PageUp | -Text Editor | -- |
| CTRL+SHIFT+Down | -CTRL+SHIFT+PageDown | -Text Editor | -- |
| Home | -Home | -Text Editor | -- |
| End | -End | -Text Editor | -- |
| SHIFT+Home | -SHIFT+Home | -Text Editor | -- |
| SHIFT+End | -SHIFT+End | -Text Editor | -- |
| ALT+SHIFT+Home | -ALT+SHIFT+Home | -Text Editor | -- |
| ALT+SHIFT+End | -ALT+SHIFT+End | -Text Editor | -- |
| CTRL+Home | -CTRL+Home | -Text Editor | -- |
| CTRL+End | -CTRL+End | -Text Editor | -- |
| CTRL+SHIFT+Home | -CTRL+SHIFT+Home | -Text Editor | -- |
| CTRL+SHIFT+End | -CTRL+SHIFT+End | -Text Editor | -- |
| CTRL+Left | -ALT+Left | -Text Editor | -- |
| CTRL+Right | -ALT+Right | -Text Editor | -- |
| CTRL+SHIFT+Left | -ALT+SHIFT+Left | -Text Editor | -- |
| CTRL+SHIFT+Right | -ALT+SHIFT+Right | -Text Editor | -- |
| BackSpace | -Delete | -Text Editor | -- |
| Delete | -Delete | -Text Editor | -- |
| Enter | -Enter | -Text Editor | -- |
| KeypadEnter | -KeypadEnter | -Text Editor | -- |
| Tab | -Tab, | -Text Editor | -- |
| SHIFT+Tab | -SHIFT+Tab, | -Text Editor | -- |
| CTRL+BackSpace | -ALT+Delete | -Text Editor | -- |
| CTRL+Delete | -CTRL+Delete | -Text Editor | -- |
| - | CMD+Delete | -Text Editor | -- |
| - | CTRL+K | -Text Editor | -- |
| F4 | -F4 | -Text Editor | -- |
| CTRL+M | -CTRL+M | -Text Editor | -- |
| CTRL+U | -CTRL+U | -Text Editor | -- |
| CTRL+Enter | -CMD+Enter | -Text Editor | -- |
| CTRL+ALT+Up | -CMD+ALT+Up | -Text Editor | -- |
| CTRL+ALT+Down | -CMD+ALT+Down | -Text Editor | -- |
| Insert | -Insert | -Text Editor | -- |
| CTRL+Space | -CTRL+Space | -Text Editor | -- |
| F6 | -F6 | -Text Editor | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| CTRL+I | -CTRL+I | -Tileset Editor | -- |
| Delete | -Delete | -Tileset Editor | -- |
| Insert | -Insert | -Tileset Editor | -- |
| Up | -Up | -Tileset Editor | -- |
| Down | -Down | -Tileset Editor | -- |
| Left | -Left | -Tileset Editor | -- |
| Right | -Right | -Tileset Editor | -- |
| SHIFT+Up | -SHIFT+Up | -Tileset Editor | -- |
| SHIFT+Down | -SHIFT+Down | -Tileset Editor | -- |
| SHIFT+Left | -SHIFT+Left | -Tileset Editor | -- |
| SHIFT+Right | -SHIFT+Right | -Tileset Editor | -- |
| KeypadPlus | -KeypadPlus | -Tileset Editor | -- |
| KeypadMinus | -KeypadMinus | -Tileset Editor | -- |
| CTRL+SHIFT+O | -CMD+SHIFT+O | -Tileset Editor | -- |
| CTRL+B | -CMD+B | -Tileset Editor | -- |
| CTRL+ALT+T | -CMD+ALT+T | -Tileset Editor | -- |
| CTRL+A | -CMD+A | -Tileset Editor | -- |
| CTRL+F | -CMD+F | -Tileset Editor | -- |
| CTRL+R | -CMD+R | -Tileset Editor | -- |
| D | -D | -Tileset Editor | -- |
| E | -E | -Tileset Editor | -- |
| F | -F | -Tileset Editor | -- |
| L | -L | -Tileset Editor | -- |
| R | -R | -Tileset Editor | -- |
| S | -S | -Tileset Editor | -- |
| A | -A | -Tileset Editor | -- |
| Z | -Z | -Tileset Editor | -- |
| Del | -Del | -Tileset Editor | -- |
| G | -G | -Tileset Editor | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| Insert | -Enter | -Timeline Editor | -- |
| SHIFT+Delete | -SHIFT+Delete | -Timeline Editor | -- |
| CTRL+Insert | -CTRL+Insert | -Timeline Editor | -- |
| SHIFT+Insert | -SHIFT+Insert | -Timeline Editor | -- |
| CTRL+SHIFT+E | -CMD+SHIFT+E | -Timeline Editor | -- |
| CTRL+SHIFT+M | -CMD+SHIFT+M | -Timeline Editor | -- |
| CTRL+U | -CMD+U | -Timeline Editor | -- |
| ALT+Enter | -ALT+Enter | -Timeline Editor | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| Insert | -- | Context Menu | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| CTRL+G | -- | Text Editor | -- |
| ALT+SHIFT+Left | -- | Text Editor | -- |
| ALT+SHIFT+Right | -- | Text Editor | -- |
| Windows Key Binding | macOS Key Binding | Scope | Description |
|---|---|---|---|
| CTRL+ALT+M | -- | Global | -- |
Keyword Description Goes Here.
-Additional Information Goes Here.
--
keyword_name(arguments);
-| Argument | -Type | -Description | -
|---|---|---|
| argument_name | -<Type_ Variable> | -Argument Description Goes Here | -
-
<Type_ Variable> (Optional explanation)
--
code_example () {
-
- }
Explain The Code Example Here
--
- - - - - \ No newline at end of file diff --git a/Manual/_page_generation/Template_Normal_Page.htm b/Manual/_page_generation/Template_Normal_Page.htm deleted file mode 100644 index ac45a138b..000000000 --- a/Manual/_page_generation/Template_Normal_Page.htm +++ /dev/null @@ -1,40 +0,0 @@ - - - - - -
-
-
-
- - - - - - \ No newline at end of file diff --git a/Manual/_page_generation/Template_Visual_Page.htm b/Manual/_page_generation/Template_Visual_Page.htm deleted file mode 100644 index 820bb10c1..000000000 --- a/Manual/_page_generation/Template_Visual_Page.htm +++ /dev/null @@ -1,58 +0,0 @@ - - - - - -
INSERT_TITLEDescription
--
| Argument | -Description | -
|---|---|
| - | - |
-
The above actions
-
- - - - - \ No newline at end of file diff --git a/Manual/_page_generation/insert_text.bat b/Manual/_page_generation/insert_text.bat deleted file mode 100644 index 322eae9d1..000000000 --- a/Manual/_page_generation/insert_text.bat +++ /dev/null @@ -1,13 +0,0 @@ -@echo off -set inputfile=%1 -set outputfile=%2 -set texttofind=%3 -set texttoprepend=%~4 - -set inserted=0 ->"%outputfile%" ( - for /f "usebackq delims=" %%a in ("%inputfile%") do ( - if %inserted%==0 if "%%~a"==%texttofind% echo(%texttoprepend% & set inserted=1 - echo(%%a - ) -) \ No newline at end of file diff --git a/Manual/_page_generation/replace_text.bat b/Manual/_page_generation/replace_text.bat deleted file mode 100644 index 4e9b544a0..000000000 --- a/Manual/_page_generation/replace_text.bat +++ /dev/null @@ -1,20 +0,0 @@ -@echo off -REM -- Prepare the Command Processor -- -SETLOCAL ENABLEEXTENSIONS -SETLOCAL DISABLEDELAYEDEXPANSION - -::BatchSubstitude - parses a File line by line and replaces a substring" -::syntax: BatchSubstitude.bat OldStr NewStr File -:: OldStr [in] - string to be replaced -:: NewStr [in] - string to replace with -:: File [in] - file to be parsed -:$changed 20100115 -:$source https://www.dostips.com -if "%~1"=="" findstr "^::" "%~f0"&GOTO:EOF -for /f "tokens=1,* delims=]" %%A in ('"type %3|find /n /v """') do ( - set "line=%%B" - if defined line ( - call set "line=echo.%%line:%~1=%~2%%" - for /f "delims=" %%X in ('"echo."%%line%%""') do %%~X - ) ELSE echo. -) \ No newline at end of file diff --git a/Manual/contents/Additional_Information/Additional_Information.htm b/Manual/contents/Additional_Information/Additional_Information.htm index 7a7b1ba32..281b14cd2 100644 --- a/Manual/contents/Additional_Information/Additional_Information.htm +++ b/Manual/contents/Additional_Information/Additional_Information.htm @@ -3,10 +3,10 @@ -
This section of the manual contain a collection of miscellaneous articles related to programming and the way the GameMaker Language works. The following articles are designed as companion articles to further expand your understanding of how GameMaker works and how to get the most from the different language features available:
+Ta część podręcznika zawiera zbiór różnych artykułów związanych z programowaniem i sposobem działania GameMaker Language. Poniższe artykuły zostały pomyślane jako artykuły towarzyszące, aby jeszcze bardziej poszerzyć wiedzę o tym, jak działa GameMaker i jak w pełni wykorzystać różne dostępne funkcje języka:
-
+
+
+
-
On this page we are going to cover some "best practices" when programming your game, and at the same time explain a little bit about the inner workings of GameMaker. Before continuing, however, it is worth noting two very important points:
+Na tej stronie zamierzamy omówić kilka "najlepszych praktyk" przy programowaniu gry, a jednocześnie wyjaśnić trochę o wewnętrznym działaniu GameMakera. Zanim jednak przejdziemy dalej, warto zwrócić uwagę na dwie bardzo ważne kwestie:
With that said, lets move on and look at some general tips for writing good GML code that you can apply at any time...
- +W związku z tym, przejdźmy dalej i spójrzmy na kilka ogólnych wskazówek dotyczących pisania dobrego kodu GML, które można zastosować w dowolnym momencie...
+When it comes to writing code everyone has a style. The style you program in is the way you place your brackets, how you indent the lines, and how you declare and name variables, etc., and is essential to making your code clear and readable to other people (and to your future self, when you have to come back to this project after a time on something else).
-There are many, many programming styles, and some would argue that theirs is the best one to use, but the truth is that almost any style is fine as long as you are consistent when using it and it is clear and obvious what everything is and does.
-
The above image is an example of a function declaration in a script to illustrate the above points. You can see that it uses the JSDoc style comments to clearly explain what it all does, and the coding style is consistent, with 4 space indents, underscores used for local vars, logged output, etc...
Also note that while the script editor permits you to fold code at each of the open/close brackets, you can use #region and #endregion tags to section off parts of your code and greatly enhance readability, especially when dealing with larger scripts which contain multiple functions. Regions can be commented, too - see the Editing section of this page in the manual):
-
When writing code, you should be aware that when compiling your final game, GameMaker strips out comments, removes unnecessary line breaks and whitespace, substitutes in constant/macro/enum values, and generally compresses your code down as part of the process. This means that you can add as much whitespace around your code as required and you don't need to worry about keeping your comments short or only using them sparingly.
+
Jeśli chodzi o pisanie kodu, każdy ma swój styl. Styl, w którym programujesz, to sposób, w jaki umieszczasz nawiasy, jak wcina się linie, jak deklarujesz i nazywasz zmienne itp. i jest niezbędny, aby twój kod był jasny i czytelny dla innych ludzi (i dla twojego przyszłego ja, kiedy będziesz musiał wrócić do tego projektu po czasie spędzonym nad czymś innym).
+Istnieje wiele, wiele stylów programowania, a niektórzy twierdzą, że ich jest najlepszy do użycia, ale prawda jest taka, że prawie każdy styl jest w porządku, o ile jesteś konsekwentny podczas korzystania z niego i jest jasne i oczywiste , co wszystko jest i robi.
+Powyższy obraz jest przykładem deklaracji funkcji w script, aby zilustrować powyższe punkty. Możesz zobaczyć, że używa komentarzy w stylu JSDoc, aby wyraźnie wyjaśnić, co to wszystko robi, a styl kodowania jest spójny, z 4 spacjami wcięciami, podkreśleniami używanymi do lokalnych vars, logowanym wyjściem, itp.
Zauważ również, że podczas gdy edytor script pozwala na składanie kodu w każdym z nawiasów otwierających/zamykających, możesz użyć znaczników #region i #endregion, aby wydzielić części kodu i znacznie zwiększyć czytelność, zwłaszcza gdy masz do czynienia z większymi scripts, które zawierają wiele funkcji. Regiony można też komentować - patrz rozdział Edycja na tej stronie w podręczniku):
+Kiedy piszesz kod, powinieneś być świadomy tego, że podczas kompilacji Twojej finalnej gry, GameMaker usuwa komentarze, usuwa niepotrzebne przerwy w liniach i białe przestrzenie, zastępuje wartości stałe/makro/enum i ogólnie kompresuje Twój kod jako część procesu. Oznacza to, że możesz dodać tyle białej przestrzeni wokół swojego kodu, ile potrzebujesz i nie musisz się martwić o to, że komentarze będą krótkie lub że będziesz ich używał oszczędnie.
Continuing on from the above point about programming style, one thing that a lot of beginners do is to cram as much into one line of code as possible. For example:
+Kontynuując powyższy punkt dotyczący stylu programowania, jedną z rzeczy, którą robi wielu początkujących, jest upchnięcie jak najwięcej w jednej linii kodu. Na przykład:
draw_sprite(sprite_index, image_index, x + lengthdir_x(100, point_direction(x, y, mouse_x, mouse_y)), y + lengthdir_y(100, point_direction(x, y, mouse_x, mouse_y)));
-While not completely unreadable, it is inefficient (the point_direction() function is called twice, for example) and it is messy and awkward to look at. It would be far better expressed as:
+Chociaż nie jest całkowicie nieczytelny, jest nieefektywny (funkcja point_direction() jest wywoływana dwa razy, na przykład) i jest niechlujny i niewygodny do oglądania. Byłoby to o wiele lepiej wyrażone jako:
var p_dir = point_direction(x, y, mouse_x, mouse_y);
var local_x = x + lengthdir_x(100, p_dir);
var local_y = y + lengthdir_y(100, p_dir);
draw_sprite(sprite_index, image_index, local_x, local_y);
The memory and resources required to create those local variables are negligible, and are far outweighed by the instant benefit you (or anyone else reading the code later) gets from its clarity. The same idea should be applied to functions too, where you should assign sensible names to the input variables, and use clear formatting and local variables where required to make it as readable as possible.
-Local variables are fast to process in-game, so make the most of them, and if an expression appears in a code block or script two or more times, think about creating a local variable for it. When using the YoYo Compiler (YYC) targets, if you reference global or instance variables various times in a function or code block it is particularly beneficial to assign them to a local variable at the start of your code and then reference that local variable, as this will give much better performance.
-+
Pamięć i zasoby wymagane do stworzenia tych zmiennych lokalnych są znikome i są znacznie przewyższone przez natychmiastową korzyść, jaką ty (lub ktokolwiek inny czytający kod później) otrzymuje z jego przejrzystości. Ta sama idea powinna być stosowana również do funkcji, gdzie powinieneś przypisać rozsądne nazwy do zmiennych wejściowych i użyć wyraźnego formatowania i zmiennych lokalnych, gdzie jest to wymagane, aby uczynić go tak czytelnym, jak to możliwe.
+Zmienne lokalne są szybko przetwarzane w grze, więc wykorzystaj je jak najlepiej, a jeśli jakieś wyrażenie pojawia się w bloku kodu lub na stronie script dwa lub więcej razy, pomyśl o stworzeniu dla niego zmiennej lokalnej. Podczas korzystania z celów YoYo Compiler (YYC), jeśli odwołujesz się do global lub zmiennych instancji wiele razy w funkcji lub bloku kodu, szczególnie korzystne jest przypisanie ich do zmiennej lokalnej na początku kodu, a następnie odwołanie się do tej zmiennej lokalnej, ponieważ daje to znacznie lepszą wydajność.
+
Arrays are fast to use and require less memory than data-structures, but they can be optimised further still. When you create an array, memory is allocated to it based on its size, so you should try to initialise an array to its maximum size first, even if you don't plan on filling it until later on. For example, if you know you need an array to hold a maximum of 100 values, you would initialise it to 100 slots straight away, using the array_create() function:
+Tablice są szybkie w użyciu i wymagają mniej pamięci niż struktury danych, ale można je jeszcze bardziej zoptymalizować. Kiedy tworzysz tablicę, pamięć jest przydzielana na podstawie jej rozmiaru, więc powinieneś spróbować zainicjować tablicę do jej maksymalnego rozmiaru, nawet jeśli nie planujesz jej wypełnienia do późniejszego czasu. Na przykład, jeśli wiesz, że potrzebujesz tablicy do przechowywania maksymalnie 100 wartości, zainicjalizowałbyś ją od razu do 100 slotów, używając array_create() funkcja:
array = array_create(100, 0);
-This allocates the memory for it in one "chunk" with all array values being set to the default value of 0 and helps keep things fast, as otherwise every time you add a new value to the array the entire memory has to be re-allocated again.
-NOTE On the HTML5 target assigning arrays like this does not apply and your arrays should be initialised from 0 for this target! You can easily handle this by checking the os_browser variable, for example:
+To przydziela pamięć dla niej w jednym "kawałku" z wszystkimi wartościami tablicy ustawionymi na domyślną wartość 0 i pomaga utrzymać rzeczy szybko, ponieważ w przeciwnym razie za każdym razem, gdy dodajesz nową wartość do tablicy, cała pamięć musi być ponownie przydzielona.
+UWAGA Na celu HTML5 przypisywanie tablic w ten sposób nie ma zastosowania, a twoje tablice powinny być inicjalizowane od 0 dla tego celu! Możesz łatwo sobie z tym poradzić, sprawdzając zmienną os_browser, na przykład:
if (os_browser == browser_not_a_browser)
{
array_create(100, 0);
@@ -60,36 +60,53 @@ Best Practices When Programming
array[i] = 0;
}
}
You can also free up the memory associated with an array by setting the variable used to equal 0. So, to clear the array from the code example above you would simply use:
+Możesz również zwolnić pamięć związaną z tablicą, ustawiając używaną zmienną na równość 0. Tak więc, aby wyczyścić tablicę z powyższego przykładu kodu, po prostu użyłbyś:
array = 0;
-+
Zauważ również, że tablice są przekazywane przez odniesienie, ale będą kopiować całość, gdy nastąpi zmiana (to zachowanie nazywa się copy on write). Tak więc, jeśli przekazujesz tablicę do funkcji, przekazujesz referencję do oryginalnej tablicy, a wszelkie wartości odczytane z niej będą pochodzić z oryginalnego źródła. Jest to miłe i szybkie, ale jeśli musisz zmodyfikować dowolną wartość tablicy, sama tablica jest duplikowana w punkcie zapisu, a wszelkie dokonane zmiany muszą zostać zwrócone z funkcji lub zostaną utracone. Jest to znacznie wolniejsze i zużywa więcej pamięci, więc uważaj, jak używasz tablic w funkcjach.
+Można jednak uniknąć tego zachowania copy on write, używając specjalnego accessora tablicowego @, ponieważ daje to bezpośredni dostęp do tablicy bazowej. Na przykład:
+// Call a function, passing our array
+ my_function(my_array);
// The function looks like this:
+
+ function my_function(_a)
+ {
+ // The array will be copied and the copy modified,
+ // requiring you to use "return _a", later
+ _a[0] = 100;
+
+ // This will modify the ORIGINAL array directly and
+ // does not require it to be returned
+ _a[@ 0] = 100;
+ }
+
In GameMaker data structures have been optimised to be a lot faster than previous GameMaker versions. They still need to be cleaned up (destroyed) when not used to free memory, and they can still be slower than, say, arrays, but the ease of use and the extra functions for dealing with the data they contain can often out-weigh the minimal speed difference, so don't be afraid to use them in your games.
-It should be noted that of all the data structures, DS Maps in particular are lighting fast, both to read from and write to, making them an excellent option for all types of tasks.
-Previously we mentioned accessors for arrays, but they are also available for data structures, which can help clean up your code and make it much easier to read.
-+
W GameMakerze struktury danych zostały zoptymalizowane tak, aby były o wiele szybsze niż w poprzednich wersjach GameMaker. Nadal muszą być czyszczone (niszczone), gdy nie są używane, aby zwolnić pamięć, i nadal mogą być wolniejsze niż, powiedzmy, tablice, ale łatwość użycia i dodatkowe funkcje do radzenia sobie z danymi, które zawierają, często przewyższają minimalną różnicę w prędkości, więc nie bój się używać ich w swoich grach.
+Należy zauważyć, że ze wszystkich struktur danych, DS Maps w szczególności są oświetleniem szybkie, zarówno do odczytu z i zapisu do, co czyni je doskonałą opcją dla wszystkich rodzajów zadań.
+Wcześniej wspomnieliśmy o accessorach dla tablic, ale są one również dostępne dla struktur danych, co może pomóc w oczyszczeniu twojego kodu i uczynić go znacznie łatwiejszym do odczytania.
+
There are multiple ways to deal with collisions in GameMaker, and most of them come with a bit of extra CPU overhead attached. The collision_ and point_ functions, place_ functions, and instance_ functions all rely on bounding box checks with all instances of a given type within the room, and while there is some optimisation built in to the engine to limit these checks, collisions are never the most effecient thing to deal with. If you start to use precise collisions, performance will also get noticably worse, as not only will you be doing bounding box checks, but you will also be doing per-pixel checks, which is very slow indeed.
+Istnieje wiele sposobów radzenia sobie z kolizjami w GameMakerze, a większość z nich wiąże się z dodatkowym obciążeniem procesora. Funkcje collision_ i point_, place_ oraz instance_ polegają na sprawdzaniu pól ograniczających dla wszystkich instancji danego typu w obrębie room i chociaż silnik posiada pewną optymalizację, która ogranicza te sprawdzenia, kolizje nigdy nie są najbardziej wydajną rzeczą. Jeśli zaczniesz używać precyzyjnych kolizji, wydajność również ulegnie zauważalnemu pogorszeniu, ponieważ nie tylko będziesz sprawdzał bounding box, ale również będziesz sprawdzał per-pixel, co jest bardzo powolne.
That is not to say that you shouldn't use these functions, as they can be very handy. However, you should know which ones to use and when, as they all work slightly differently and will have different speeds. Rough rule of thumb is that the place_ functions are faster than the instance_ functions, which are faster than the collision_ and point_ functions, so read the pages in the manual for each of these types of functions and make sure to choose the most appropriate for every situation.
-Alternatively, look into creating a tile-based collision system, which can be created using the tilemap functions or even a custom 2D array or DS grid. These will be very fast and will help boost your game's speed. However, if you are using irregular terrain or walls and objects that don't align to a grid they may not be appropriate. You can find a very simple tutorial on tilemap collisions from the following video link
+Nie oznacza to, że nie powinieneś używać tych funkcji, ponieważ mogą być bardzo przydatne. Powinieneś jednak wiedzieć, których z nich używać i kiedy, ponieważ wszystkie działają nieco inaczej i mają różne prędkości. Z grubsza zasada jest taka, że funkcje place_ są szybsze niż funkcje instance_, które są szybsze niż funkcje collision_ i point_, więc przeczytaj strony w instrukcji dla każdego z tych typów funkcji i upewnij się, że wybierasz najbardziej odpowiednie dla każdej sytuacji.
+Alternatywnie, spójrz na stworzenie systemu kolizji opartego na kafelkach, które można utworzyć za pomocą funkcji tilemap lub nawet niestandardowej tablicy 2D lub siatki DS. Będą one bardzo szybkie i pomogą zwiększyć szybkość gry. Jednakże, jeśli używasz nieregularnego terenu lub ścian i objects, które nie są wyrównane do siatki, mogą one nie być odpowiednie. Bardzo prosty tutorial na temat kolizji z mapami można znaleźć w poniższym linku wideo
-+
Texture Swaps And Vertex Batches
+Zamiana tekstur i partie wierzchołków
If you switch on the debug overlay, you will see that there are two figures in brackets at the top of your screen when testing. The first is the number of texture swaps being done and the second is the number of vertex batches. A number of factors will influence these figures and you will never get them down to (0) (0) as the engine requires one or two of each every step, but you should aim to get these values down as low as possible.
-
For texture swaps, the best and most efficient way to do this is to optimise how your sprites and backgrounds are stored on the texture page. This is done from the sprite properties, and you can create texture pages in the Texture Group Editor. If you have a number of images that are only used in the main menu (for example), then put them together on a separate texture page. The same if you have level-specific images, or the player and the enemies, etc. Basically, you want to group them by use so that the swaps are reduced as much as possible. Additionally, to help keep VRAM optimised you can then use the different prefetch and flush functions to load and remove textures from memory as required.
NOTE As mentioned at the start of this page, if your game runs fine with a decent FPS then don't worry too much about texture swaps... especially when creating projects on the desktop targets. These optimisations are best when used with large games or on low-end mobile devices, and when used incorrectly can they actually negatively impact performance.
-Vertex information is sent in "batches" to the GPU for drawing, and in general the larger the batch the better. So "breaking" the batch should be avoided when drawing, as that will increase the number of vertex batches sent to the GPU. There are a number of things that will break the batch, with the main ones being blend modes, changing the shader, changing a uniform for a shader before drawing something, and drawing using the built-in shapes and primitives.
-So, if you have a number of bullet instances that draw using the bm_add blend mode - for example - you will be creating a new vertex batch for each one, which is definitely a bad thing! Instead, have a controller object in your game that draws all the bullets instead, like this:
+Jeśli switch na nakładka debugowania, zobaczysz, że podczas testowania na górze ekranu znajdują się dwie liczby w nawiasach. Pierwsza to liczba wykonywanych wymian tekstur , a druga to liczba partii wierzchołków. Wiele czynników ma wpływ na te liczby i nigdy nie uda Ci się ich sprowadzić do (0) (0), ponieważ silnik wymaga jednego lub dwóch z każdego kroku, ale powinieneś dążyć do tego, aby te wartości były jak najniższe.
+W przypadku zamiany texture najlepszym i najbardziej efektywnym sposobem jest optymalizacja sposobu przechowywania sprites i tła na stronie texture. Robi się to we właściwościach sprite'a, a strony texture można tworzyć w edytorze grup tekstur. Jeśli masz kilka obrazów, które są używane tylko w menu głównym (na przykład), to umieść je razem na osobnej stronie tekstur. To samo, jeśli masz obrazy specyficzne dla poziomu, lub gracza i wrogów, itp. Zasadniczo, chcesz je pogrupować według użycia, aby zamiany były zredukowane tak bardzo, jak to możliwe. Dodatkowo, aby pomóc w optymalizacji VRAM, możesz następnie użyć różnych funkcji prefetch i flush, aby załadować i usunąć textures z pamięci w razie potrzeby.
UWAGA Jak wspomniano na początku tej strony, jeśli Twoja gra działa dobrze z przyzwoitym FPS, to nie przejmuj się zbytnio podmianami texture... zwłaszcza przy tworzeniu projektów na cele desktopowe. Te optymalizacje są najlepsze, gdy są używane z dużymi grami lub na urządzeniach mobilnych o niskiej wydajności, a gdy są używane niepoprawnie, mogą faktycznie negatywnie wpłynąć na wydajność.
+Informacje o wierzchołkach są wysyłane w "partiach" do GPU w celu rysowania i generalnie im większa partia, tym lepiej. Należy więc unikać "przerywania" partii podczas rysowania, ponieważ zwiększy to liczbę partii wierzchołków wysyłanych do GPU. Istnieje wiele rzeczy, które spowodują przerwanie partii, a główne z nich to tryby mieszania, zmiana shadera, zmiana uniformu na shader przed rysowaniem czegoś, a także rysowanie przy użyciu wbudowanych kształtów i prymitywów.
+Tak więc, jeśli masz kilka instancji pocisków, które rysują się przy użyciu trybu mieszania bm_add - na przykład - będziesz tworzyć nową vertex batch dla każdego z nich, co jest zdecydowanie złą rzeczą! Zamiast tego, miej kontroler object w swojej grze, który rysuje wszystkie pociski zamiast tego, jak to:
gpu_set_blendmode(bm_add);
with (obj_BULLET)
@@ -99,45 +116,45 @@
NOTE This doesn't just apply to using bm_add - any blending change will break the batch and will give a performance hit.
-In this way, all the bullets will be drawn in the same batch. Judicious use of the functions gpu_set_blendenable(), gpu_set_alphatestref(), and gpu_set_alphatestenable() can greatly improve performance and can be enabled/disabled as required throughout your project code, although they may not be appropriate for all types of graphics or projects.
-NOTE If you don't require the instance to draw itself when using a controller in this way then you can simply add a comment into the Draw Event to suppress the default drawing, or make the instance invisible (although this will prevent all code running for the instance in all draw events).
-Another way to reduce these numbers is to disable the Separate Texture Page option for sprites unless absolutely necessary. Each image stored in this way is sent to its own texture page and batched differently, so having these images on a regular texture page is better. You can then get the UVS coordinates using the sprite_get_uvs() function and store them in variables for use later. It may be a small amount of extra code, but the boost you will get is worth it. Note that this method will not permit texture repeats!
-As with all these tips, if it makes your life more difficult to change it and your game runs fine, don't worry about it too much...
-+
UWAGA To nie dotyczy tylko użycia bm_add - każda zmiana mieszania przerwie partię i spowoduje wzrost wydajności.
+W ten sposób wszystkie kule zostaną narysowane w tej samej partii. Rozsądne korzystanie z funkcji. gpu_set_blendenable(), gpu_set_alphatestref(), i gpu_set_alphatestenable() może znacznie poprawić wydajność i mogą być włączone/wyłączone w zależności od potrzeb w całym kodzie projektu, chociaż mogą nie być odpowiednie dla wszystkich rodzajów grafiki lub projektów.
+UWAGA Jeśli nie wymagasz, aby instancja rysowała się podczas używania kontrolera w ten sposób, wtedy możesz po prostu dodać komentarz do zdarzenia Draw, aby stłumić domyślne rysowanie, lub uczynić instancję niewidoczną (chociaż uniemożliwi to cały kod działający dla instancji we wszystkich zdarzeniach draw).
+Innym sposobem na zmniejszenie tych liczb jest wyłączenie opcji Oddzielna strona Texture dla sprites, chyba że jest to absolutnie konieczne. Każdy obraz przechowywany w ten sposób jest wysyłany na własną stronę texture i różnie pakowany, więc posiadanie tych obrazów na zwykłej stronie texture jest lepsze. Następnie możesz uzyskać współrzędne UVS używając funkcji sprite_get_uvs() i przechowywać je w zmiennych do późniejszego wykorzystania. Może to być niewielka ilość dodatkowego kodu, ale wzrost, który uzyskasz, jest tego wart. Zauważ, że ta metoda nie pozwoli na powtórzenia texture!
+Tak jak w przypadku wszystkich tych porad, jeśli utrudnia ci życie zmiana, a twoja gra działa dobrze, nie przejmuj się tym zbytnio...
+
Particles offer a very quick and efficient way to create dynamic effects in your game, and in general they give good performance. However, it's worth noting that using additive blending, alpha blending and colour blending on the particles may lower that performance, especially on mobile targets, so if you don't need it don't use it! Additive blending, in particular, can greatly increase the vertex batches and should be used with care.
-Note that on the non-WebGL HTML5 target, having multi-coloured, fading particles will require a lot of image caching and will be very slow. However, since particle sprites can be animated, you can create an animated sprite that has sub-images which change colour and then use that for the particle instead. It will still look like a gradual colour change, but not require the constant creation of cache images.
-You can find out more about particles from the page Guide To Using Particles.
-+
Cząstki oferują bardzo szybki i wydajny sposób tworzenia dynamicznych efektów w twojej grze i generalnie dają dobrą wydajność. Warto jednak zauważyć, że używanie additive blending, alpha blending i color blending na cząsteczkach może obniżyć tę wydajność, zwłaszcza na urządzeniach mobilnych, więc jeśli nie potrzebujesz tego, nie używaj! Additive blending, w szczególności, może znacznie zwiększyć partie wierzchołków i powinien być używany ostrożnie.
+Zauważ, że w przypadku nie-WebGL HTML5, posiadanie wielokolorowych, zanikających cząstek będzie wymagało dużego buforowania obrazu i będzie bardzo powolne. Jednakże, ponieważ cząstki sprites mogą być animowane, możesz stworzyć animowany sprite, który ma pod-obrazy, które zmieniają kolor, a następnie użyć go dla cząstki zamiast. Nadal będzie to wyglądać jak stopniowa zmiana koloru, ale nie będzie wymagać ciągłego tworzenia obrazów cache.
+Więcej o cząsteczkach można dowiedzieć się ze strony Przewodnik po używaniu cząsteczek.
+
Finally, we're going to touch briefly on using surfaces, as GameMaker has a fairly significant optimisation when using them in your games: the ability to switch on and off the depth buffer.
-When you just use surfaces as normal, GameMaker will actually create a surface and an accompanying depth buffer to ensure proper depth sorting when drawing anything in 3D. However, for most 2D games, this extra depth buffer is just not required and so is taking up extra memory space and processing time that could be used for other things. This is where the function surface_depth_disable() comes into play...
-This function can be called before you create a surface to disable the depth buffer generation, and all surfaces created afterwards will not have a depth buffer created for them. You can enable/disable this function as required, and can even call it once at the start of the game to disable depth buffers for all subsequent surface calls (and in most 2D games this is fine). It won't give a major performance boost, but it's certainly something to keep in mind if your game relies heavily on surfaces and might stop your game running out of memory on lower-specced devices.
+Na koniec poruszymy krótko temat używania powierzchni, ponieważ GameMaker posiada dość istotną optymalizację przy używaniu ich w swoich grach: możliwość switch włączania i wyłączania bufora głębi.
+Kiedy po prostu używasz powierzchni jak zwykle, GameMaker faktycznie stworzy powierzchnię i towarzyszącą jej głębię buffer, aby zapewnić prawidłowe sortowanie głębokości podczas rysowania czegokolwiek w 3D. Jednak w większości gier 2D, ta dodatkowa głębia buffer nie jest po prostu wymagana i zajmuje dodatkowe miejsce w pamięci i czas przetwarzania, który mógłby być wykorzystany do innych rzeczy. To właśnie tutaj funkcja surface_depth_disable() wchodzi w grę...
+Tę funkcję można wywołać przed utworzeniem powierzchni, aby wyłączyć generowanie głębi buffer, a wszystkie powierzchnie utworzone później nie będą miały utworzonej głębi buffer dla nich. Możesz włączyć/wyłączyć tę funkcję w zależności od potrzeb, a nawet możesz ją wywołać raz na początku gry, aby wyłączyć głębię buffers dla wszystkich kolejnych wywołań powierzchni (w większości gier 2D jest to w porządku). Nie spowoduje to znacznego wzrostu wydajności, ale z pewnością warto o tym pamiętać, jeśli Twoja gra w dużej mierze opiera się na powierzchniach i może powstrzymać grę przed wyczerpaniem pamięci na urządzeniach o niższej specyfikacji.
-
Apart from the main things mentioned above, there are other more general things that can help with performance and that are considered "good practices" too:
++
Oprócz głównych rzeczy wymienionych powyżej, istnieją inne bardziej ogólne rzeczy, które mogą pomóc w wydajności i które są również uważane za "dobre praktyki":
But, as we mentioned at the start of the page, all these optimisations are optional and if your game runs fine with 60 vertex batches, 80 texture swaps, additive blending, etc., then don't worry about it too much! Just keep these things in mind when programming your next game...
--
-
+
Ale, jak wspomnieliśmy na początku strony, wszystkie te optymalizacje są opcjonalne i jeśli twoja gra działa dobrze z 60 partiami wierzchołków, 80 texture swaps, additive blending, itp. to nie przejmuj się tym zbytnio! Po prostu pamiętaj o tych rzeczach podczas programowania następnej gry...
++
+
-
At the beginning of the computer era, binary and hex (hexadecimal) were a way of life, probably because high level languages (such as BASIC) were simply too slow to run. For example, multiplying 32 x 32 might have taken various CPU cycles to achieve using BASIC, but with binary it is done as a single operation in a single CPU cycle.
-These days however, with the power of even a basic PC, you no longer have to worry about this and you can do things the "long way", since the speed of the machine and its more complex CPU construction will make up for any short comings this approach has. This is great news of course, since it means that you no longer have to optimise every line of code you write, but if this is the case - should you really care about binary at all?
-The answer is definitely "yes, you should". While it's true you can still get some speed ups - and sometimes these can be significant - using binary and hex leads to a better understanding of how the CPU operates and can also lead to writing better code, being able to pack data better, and making some tasks a lot simpler. This page is going to explain a bit about what binary is as well as how it can be used when making your games.
-To write binary literals in GML, prefix them with 0b (e.g. 0b0010). See Data Types for more information.
-Let's look at the most basic binary theory first - how numbers are created. Take a look at this table:
+Na początku ery komputerów binarne i heksadecymalne (szesnastkowe) były sposobem na życie, prawdopodobnie dlatego, że języki wysokiego poziomu (takie jak BASIC) były po prostu zbyt wolne do uruchomienia. Na przykład pomnożenie liczby 32 x 32 w języku BASIC mogło zająć wiele cykli procesora, natomiast w języku binarnym jest to pojedyncza operacja wykonywana w jednym cyklu procesora.
+W dzisiejszych czasach, przy mocy nawet podstawowego komputera PC, nie trzeba się już o to martwić i można robić rzeczy "długą drogą", ponieważ szybkość maszyny i bardziej złożona konstrukcja procesora nadrobią wszelkie niedociągnięcia takiego podejścia. Jest to oczywiście wspaniała wiadomość, ponieważ oznacza, że nie trzeba już optymalizować każdej linijki kodu, który się pisze, ale jeśli tak jest, to czy w ogóle powinno się dbać o binarność?
+Odpowiedź brzmi zdecydowanie "tak, powinieneś". Prawdą jest, że nadal można uzyskać pewne przyrosty prędkości - a czasami mogą one być znaczące - ale używanie binarnego i szesnastkowego kodu prowadzi do lepszego zrozumienia sposobu działania procesora, a także może prowadzić do pisania lepszego kodu, lepszego pakowania danych i uproszczenia niektórych zadań. Ta strona wyjaśni nieco, czym jest binarność oraz jak można jej używać podczas tworzenia gier.
+Przyjrzyjmy się więc najpierw najbardziej podstawowej teorii binarnej - jak powstają liczby. Spójrzmy na tę tabelę:
000 = 0
001 = 1
010 = 2
100 = 4
Each 1 or 0 represents a single bit of data, and as you can see this means that in binary, 10 equals 2! Each bit is 2 times the previous value with the first bit being equal to 1. So bit 2 = 2, bit 3 = 4, bit 4 = 8 and so on (as shown below in this byte table):
+Każda 1 lub 0 reprezentuje jeden bit danych, a jak widać, oznacza to, że w systemie binarnym 10 równa się 2! Każdy bit jest 2 razy większy od poprzedniej wartości, przy czym pierwszy bit jest równy 1. Zatem bit 2 = 2, bit 3 = 4, bit 4 = 8 i tak dalej (jak pokazano poniżej w tabeli bajtów ):
00000001 = 1
00000010 = 2
00000100 = 4
@@ -33,74 +32,74 @@
That's fine if you want numbers that are a power of 2, but how do we create more complex numbers? Well a single binary number can only store a 0 or 1, and that's it, so for more complex numbers we need to add bits together. If for example we wanted to make 6, we would add 4 and 2 together like so.
+To dobrze, jeśli chcemy, aby liczby były potęgą dwójki, ale jak tworzyć bardziej złożone liczby? Cóż, pojedyncza liczba binarna może przechowywać tylko 0 lub 1, i to wszystko, więc aby uzyskać bardziej złożone liczby, musimy dodawać bity do siebie. Jeśli na przykład chcemy utworzyć liczbę 6, dodajemy do siebie 4 i 2 w następujący sposób.
00000010 = 2
00000100 = 4
00000110 = 6
This is true of all binary numbers, and how the computer makes up any number internally. Let's take a slightly more complicated number as a further example: 23. The number 23 is actually made up of 1+2+4+16 or 00010111. How about a much more complex example: 196? Well, that's made from 128+64+4 or 11000100. So actually it's not that complex really!
-If we start doing values outside of the range of a byte (which can store numbers from 0 to 255), it does start to get a little harder to track, however. For example, 217,361 is 110101000100010001 in binary. Or, 1+16+256+etc... The rules are the same no matter what the value being expressed is - each number is created from adding multiple bits together.
-Now, how do we perform mathematical operations on these values? Let's say you want to store true or false as a value. Usually compilers will use an INT (an INT is usually defined as a signed 32bit number - signed just means it can a positive or negative value, while unsigned means it can only be positive) and then simply assign it to 0 or 1. Having only 2 states, a true / false value is ideal to store in a bit, and if we did this we could store 32 true / false bits for each INT rather than just one, since an INT is made up of 32 bits.
-How would we do this? Well pretty easily it turns out:
+Dotyczy to wszystkich liczb binarnych oraz sposobu, w jaki komputer tworzy wewnętrznie każdą liczbę. Weźmy jako przykład nieco bardziej skomplikowaną liczbę: 23. Liczba 23 składa się w rzeczywistości z 1+2+4+16 lub 00010111. A co powiesz na znacznie bardziej skomplikowany przykład: 196? Cóż, ta liczba składa się z 128+64+4 lub 11000100. Tak więc w rzeczywistości nie jest ona aż tak skomplikowana!
+Jeśli jednak zaczniemy używać wartości spoza zakresu bajtu (który może przechowywać liczby z zakresu od 0 do 255), śledzenie ich stanie się nieco trudniejsze. Na przykład 217 361 to 110101000100010001 w systemie binarnym. Albo 1+16+256+etc... Zasady są takie same niezależnie od wyrażanej wartości - każda liczba jest tworzona przez dodanie do siebie wielu bitów.
+W jaki sposób można wykonywać operacje matematyczne na tych wartościach? Załóżmy, że chcesz zapisać true lub false jako wartość. Zazwyczaj kompilatory używają adresu INT (adres INT jest zwykle definiowany jako podpisana liczba 32-bitowa - podpisana oznacza, że może mieć wartość dodatnią lub ujemną, a niepodpisana, że tylko dodatnią), a następnie przypisują ją do adresu 0 lub 1. Mając tylko dwa stany, wartość true / false jest idealna do przechowywania w bicie, a gdybyśmy to zrobili, moglibyśmy przechowywać 32 bity true / false dla każdego adresu INT, a nie tylko jeden, ponieważ adres INT składa się z 32 bitów.
+Jak to zrobić? Okazuje się, że całkiem łatwo:
flags = flags | 1;
-The "|" operator is a bitwise OR, and this means the above instruction ORs 1 into the value held in the variable flags. If you remember from earlier, using a 1 will set the first bit. If we wanted to set the second bit, we would do this:
+Operator "|" jest operatorem bitowym OR, a to oznacza, że powyższa instrukcja ORs 1 do wartości przechowywanej w zmiennej flags. Jeśli pamiętasz z wcześniejszych lekcji, to użycie 1 spowoduje ustawienie pierwszego bitu. Gdybyśmy chcieli ustawić drugi bit, zrobilibyśmy to tak:
flags = flags | 2;
-We OR in 2, because the bit pattern 00000010 is equal to 2. So what exactly does the binary OR operator do? Well, it merges all the bits together into a single value, like this:
+Na stronie OR znajduje się 2, ponieważ wzór bitowy 00000010 jest równy 2. Co dokładnie robi operator binarny OR? Łączy wszystkie bity w jedną wartość, na przykład tak:
010110100 // Value 1
110011001 // value 2
110111101 // Value 1 OR Value 2
Here's what's known as a truth table for the OR operator:
+Oto tzw. tabela prawdy dla operatora OR:
00 | 00 = 00
00 | 01 = 01
01 | 01 = 01
01 | 00 = 01
So where there is a value with 2 zeros, it'll stay zero. The advantage of using bits like this as a true/false state, is they you can set several bits as "flags" in one operation, something you simply couldn't do with a normal boolean value. For example, let's say bit 1 is an "active" flag, and bit 3 is a "visible" flag. We could set both by doing this:
+Zatem tam, gdzie jest wartość z dwoma zerami, pozostanie ona zerem. Zaletą używania takich bitów jako stanów true/false jest to, że można ustawić kilka bitów jako "flagi" w jednej operacji, czego nie można zrobić z normalną wartością logiczną. Na przykład, powiedzmy, że bit 1 jest "aktywny" flag, a bit 3 jest "widoczny" flag. Możemy ustawić obie te wartości w ten sposób:
flags = flags | 5;
-This is because 5 is 00000101 in binary, and following the rule above, the variable "flags" will get both these 2 bits merged with its own. So even if bit 1 was already set, the operation still works and bit 3 will now also be set.
-What about clearing flags? Well this is where the bitwise "&" AND operation comes in. When you AND something, the bits that are set in the mask are kept, while the bits that are clear in the mask, are removed - like this:
+Dzieje się tak, ponieważ 5 to 00000101 w systemie binarnym, a zgodnie z powyższą regułą zmienna "flagi" otrzyma oba te bity połączone ze swoimi własnymi. Zatem nawet jeśli bit 1 był już ustawiony, operacja nadal działa, a bit 3 również zostanie ustawiony.
+A jak wyczyścić stronę flags? W tym miejscu można skorzystać z operacji bitowej "&" AND. Kiedy AND czegoś, bity, które są ustawione w masce, są zachowywane, a bity, które są czyste w masce, są usuwane - w ten sposób:
01110010101 // Value 1
00110000100 // Value 2
00110000100 // Value 1 AND value 2
As you can see, where there is a 1 in each value, the 1 is kept, and where there is a mix or 0's and 1's these are reset to 0. Here's the truth table for ANDing:
+Jak widać, tam, gdzie w każdej wartości jest 1, ta 1 jest zachowywana, a tam, gdzie jest mieszanina 0 i 1, te wartości są resetowane do 0. Oto tabela prawdy dla strony ANDing:
00 & 00 = 00
01 & 00 = 00
00 & 01 = 00
01 & 01 = 01
So, only when there is a bit in each place will it be kept. What this means, is that just as you are able to set multiple flags at once, you can also clear multiple flags at once. For example, let's take the case above, but this time clear them. We want to clear bits 1 and 3 (giving us the value 5), but in remembering the truth table above, what we want to do is keep all the other bits, and clear bits 1 and 3. This would be a binary "mask" of 11111111111111111111111111111010 (32bits). This mask keeps all bits currently set, but clears the two bits we actually want cleared. So if had a value of 1000111011 and I wanted to clear bits 1 and 3 using the mask above, it would end up as this...
+Tak więc tylko wtedy, gdy w każdym miejscu znajduje się jakiś fragment, zostanie on zachowany. Oznacza to, że tak samo jak można ustawić wiele stron flags jednocześnie, można również wyczyścić wiele stron flags jednocześnie. Na przykład, weźmy powyższy przypadek, ale tym razem wyczyśćmy je. Chcemy wyczyścić bity 1 i 3 (co da nam wartość 5), ale pamiętając o powyższej tabeli prawdy, chcemy zachować wszystkie pozostałe bity i wyczyścić bity 1 i 3. W ten sposób powstanie binarna "maska" o wartości 11111111111111111111111111111010 (32 bity). Ta maska zachowuje wszystkie aktualnie ustawione bity, ale czyści dwa bity, które mają być wyczyszczone. Gdybyśmy więc mieli wartość 1000111011 i chcieli wyczyścić bity 1 i 3 za pomocą powyższej maski, otrzymalibyśmy następujący wynik...
00000000000000000000001000111011 // Value
11111111111111111111111111111010 // Mask
00000000000000000000001000111010 // Value AND Mask
This is great, but if we had to work this out every time we needed to clear flags, it would become tiresome. What we need is a way to flip bits easily (and preferably without CPU cost). Fortunately there is an easy way of doing this by using the " ~" NOT operator.
-The NOT operator is just what it says - not those bits. Here's a truth table for NOT.
+Jest to świetne rozwiązanie, ale gdybyśmy musieli to robić za każdym razem, gdy chcemy wyczyścić stronę flags, stałoby się to męczące. Potrzebujemy sposobu na łatwe przerzucanie bitów (i najlepiej bez kosztów dla procesora). Na szczęście istnieje prosty sposób, aby to zrobić, wykorzystujący operator " ~" NOT.
+Operator NOT jest dokładnie tym, co mówi - nie tymi bitami. Oto tabela prawdy dla NOT.
~00 = 11
~01 = 10
~10 = 01
~11 = 00
This operator makes removing flags very simple, and better yet, it's usually a compile time optimisation meaning if you're using a constant number (i.e. not a variable) then the compiler will flip the bits automatically for you. Take this statement where we want to clear bits 1 and 3 again:
+Ten operator sprawia, że usuwanie flags jest bardzo proste, a co więcej, jest to zazwyczaj optymalizacja w czasie kompilacji, co oznacza, że jeśli używasz stałej liczby (tzn. nie zmiennej), to kompilator automatycznie odwróci bity za Ciebie. Weźmy na przykład poniższą instrukcję, w której chcemy ponownie wyczyścić bity 1 i 3:
a = a & ~5;
-This will actually compile down to just "a & 11111111111111111111111111111010". This makes life pretty simple in terms of clearing flags.
-The last operator we want to look at is "^" EOR (Exclusive OR, sometimes called XOR), this operator flips the bits set in both values. Here's the EOR truth table:
+W rzeczywistości skompiluje się on do postaci "a & 11111111111111111111111111111010". To bardzo upraszcza życie, jeśli chodzi o usuwanie flags.
+Ostatnim operatorem, któremu chcemy się przyjrzeć, jest "^" EOR (Exclusive OR, czasami nazywany XOR), operator ten odwraca bity ustawione w obu wartościach. Oto tabela prawdy EOR:
0 ^ 0 = 0
0 ^ 1 = 1
1 ^ 0 = 1
1 ^ 1 = 0
This is a curious one, but incredibly useful. For example, let's say we want a counter that simply counts from 0 to 1 and back to 0 (toggling between 0 and 1), we could add one and do an IF to see if it's gotten to 2, and then reset it back to 1. Or...we could add 1 and then AND it with 1 (since 01+01 = 10, and 10 & 01 = 0) or we can do this:
+Jest to bardzo ciekawe, ale niezwykle użyteczne rozwiązanie. Na przykład, powiedzmy, że chcemy mieć licznik, który po prostu liczy od 0 do 1 i z powrotem do 0 (przełączając się między 0 a 1), możemy dodać jeden i wykonać IF, aby sprawdzić, czy doszedł do 2, a następnie zresetować go z powrotem do 1. Albo... możemy dodać 1, a następnie AND ją z 1 (ponieważ 01+01 = 10, oraz 10 & 01 = 0) lub możemy zrobić tak:
a = a ^ 1;
-What this does the first time it's run is 0 ^ 1 = 1, then the second time 1 ^ 1 = 0, thereby toggling things back and forth from 0 to 1.
-So - OR (|), AND(&), NOT(~) and EOR(^) let us manipulate bits with relative ease, allowing us, at the simplest level, to control multiple bits at once. We can obviously use these operations for other things when developing our games, like masking sprites, doing integer MOD operations (using AND) or doing nice looping counters.
-So, we can do simply bitwise operations, but let's look at the more complex stuff, starting with the question, how does a computer add? Let's look at a very simple example: 1+1.
+Przy pierwszym uruchomieniu jest to 0 ^ 1 = 1, a przy drugim 1 ^ 1 = 0, co powoduje zmianę wartości z 0 na 1.
+Tak więc - OR (|), AND(&), NOT(~) i EOR(^) pozwalają nam stosunkowo łatwo manipulować bitami, umożliwiając, na najprostszym poziomie, kontrolowanie wielu bitów naraz. Podczas tworzenia gier możemy oczywiście używać tych operacji do innych rzeczy, takich jak maskowanie sprites, wykonywanie operacji na liczbach całkowitych MOD (przy użyciu AND) lub wykonywanie ładnych liczników w pętli.
+Potrafimy więc wykonywać proste operacje bitowe, ale przyjrzyjmy się bardziej złożonym zagadnieniom, zaczynając od pytania: jak komputer dodaje? Przyjrzyjmy się bardzo prostemu przykładowi: 1+1.
00000001
00000001
00000010
Just like normal additions, we add numbers together and then we overflow into the next column, but unlike a normal decimal addition, we can only go from 0 to 1, not 0 to 9. So adding a 1+1 means we overflow into 10. So let's look at a more complex example.
+Podobnie jak w normalnym dodawaniu, dodajemy liczby do siebie, a następnie przelewamy do następnej kolumny, ale w przeciwieństwie do normalnego dodawania dziesiętnego, możemy przejść tylko od 0 do 1, a nie od 0 do 9. Zatem dodanie liczby 1+1 oznacza przepełnienie do 10. Przyjrzyjmy się więc bardziej złożonemu przykładowi.
01011011 = 91
00101101 = 45
10001000 = 136
It's obviously harder to see here, but the overflows ripple along until there are no ones in a column. It's worth noting, that computers can only add (or subtract, multiply or divide) 2 numbers at once. Take 19 + 19 + 19. Being human, we can add all the 9's together, carry the 2 and then on we go! But computers can't do that - what they can do is this: (19 + 19) + 19. So they'll do each calculation in blocks of 2.
-The binary calculations that are of most interest to us as programmers are multiplication and division. Computers only multiply in 2s, and to do more it'll break a number apart, and then add all the results together. Let's take some very simple examples first. 4 * 2 = 8. Now to multiply by 2 in binary, we shift all the bits to the LEFT by one. Like this:
+Oczywiście tutaj jest to trudniej zauważyć, ale przepełnienia pojawiają się stopniowo, aż do momentu, gdy w danej kolumnie nie ma jedynek. Warto zauważyć, że komputery mogą dodawać (lub odejmować, mnożyć lub dzielić) tylko dwie liczby jednocześnie. Weźmy przykład 19 + 19 + 19. Będąc człowiekiem, możemy dodać do siebie wszystkie 9, przenieść 2 i dalej działać! Ale komputery tego nie potrafią - potrafią natomiast zrobić to: (19 + 19) + 19. Dlatego każde obliczenie wykonują w blokach po 2.
+Obliczenia binarne, które najbardziej interesują nas jako programistów, to mnożenie i dzielenie. Komputery mnożą tylko dwójkami, a żeby wykonać więcej, rozbijają liczbę na części, a następnie dodają wszystkie wyniki do siebie. Przyjrzyjmy się najpierw kilku bardzo prostym przykładom. 4 * 2 = 8. Aby pomnożyć liczbę przez 2 w układzie binarnym, należy przesunąć wszystkie bity w lewo o jeden. Na przykład tak:
00000100 * 2 = 00001000 = 8
-All the bits in this case have moved to the left by one, making it move from the 3rd bit, to the 4th, and changing the value from 4 to 8. How about a larger number?
+W tym przypadku wszystkie bity przesunęły się w lewo o jeden, co spowodowało przesunięcie z trzeciego bitu na czwarty i zmianę wartości z 4 na 8. A co powiesz na większą liczbę?
101 = 01100101 * 2 = 11001010 = 202
-Again, all the bits move on one, and that multiples by 2. So, how about a multiple by 4? Easy, we shift everything left by 2, rather than one. So how about 16, or 128? This would require a left shift of 4 bits, or 7 bits respectively. This is incredibly useful; it means we can do simple multiplications by simply moving bits around. To do this, we use the left shift operator <<. Here are some examples:
+Ponownie wszystkie bity przesuwają się o jeden, a to mnoży się przez 2. A co z mnożeniem przez 4? To proste, przesuniemy wszystko w lewo o 2, a nie o jeden. A więc co powiesz na 16 lub 128? Wymagałoby to przesunięcia w lewo odpowiednio o 4 bity lub 7 bitów. Jest to niezwykle użyteczne, ponieważ dzięki temu możemy wykonywać proste mnożenia, przesuwając bity. W tym celu używamy operatora przesunięcia w lewo <<. Oto kilka przykładów:
00000001 << 1 = 000000010 = 2
00000001 << 2 = 000000100 = 4
00000001 << 3 = 000001000 = 8
@@ -109,99 +108,99 @@
Now, aside from being very useful for fast/simple multiplications, it's also very useful for setting specific bits, without having to figure out the bit value. Let's say we wanted to set bit 27, what number is that? (67108864 by the way!), well we can use the syntax above to easily set flags like this:
+Oprócz tego, że jest to bardzo użyteczne do szybkiego i prostego mnożenia, jest to również bardzo użyteczne do ustawiania konkretnych bitów, bez konieczności ustalania ich wartości. Załóżmy, że chcemy ustawić bit 27, co to za liczba? (67108864 przy okazji!), więc możemy użyć powyższej składni, aby łatwo ustawić flags w ten sposób:
a = a | (1 << 27)
-Okay... so actually this would be bit 26 the way we've been describing things so far (as bits have been starting at one), but actually... bits start at bit 0, and go upwards, not at bit 1. So while there are 32 bits in an INTEGER, the bits range from 0 to 31, not 1 to 32. This is actually pretty useful, as we can now set up constants for bit numbers.
-So let's say Bit 27 is an active flag, and bit 0 is an exploding flag. How can we set both?
+Ok... więc właściwie byłby to bit 26, tak jak opisywaliśmy to do tej pory (ponieważ bity zaczynały się od jedynki), ale tak naprawdę... bity zaczynają się od bitu 0 i idą w górę, a nie od bitu 1. Tak więc, choć w liczbie INTEGER są 32 bity, to są to bity z zakresu od 0 do 31, a nie od 1 do 32. Jest to całkiem przydatne, ponieważ możemy teraz ustawić stałe dla liczb bitowych.
+Załóżmy więc, że bit 27 to aktywny flag, a bit 0 to eksplodujący flag. Jak możemy ustawić oba?
ACTIVE = 27;
BOOM = 0;
A = A | (1 << ACTIVE) | (1 << BOOM);
This may look like a lot of code, but if these numbers are constants, the compiler will pre-compile these operations into a single value so that we end up with this as actual code.
+Może to wyglądać na dużą ilość kodu, ale jeśli liczby te są stałe, kompilator wstępnie skompiluje te operacje w jedną wartość, dzięki czemu otrzymamy taki właśnie kod.
A = A | 13421772;
-Clearing these bits (as we saw above) is simply a matter of using the NOT modifier, like this:
+Usuwanie tych bitów (jak widzieliśmy powyżej) polega po prostu na użyciu modyfikatora NOT, jak poniżej:
A = A & ~((1 << ACTIVE) | (1 << BOOM));
-So this happily lets us set and clear any bits we'd like, and it also lets us compress out data structures massively. Compressing data structures is a good thing, because if you use less memory, you get less cache misses, and your code just runs faster. Put it this way, what's quicker, copying 32Mb or data, or 4Mb? Well, quite clearly 4 is. So if you can pack all yours flags down into a single memory access, this is good!
-Now, let's take a quick look at how you do division, and why it's going to be so useful. Division is done by shifting the bits right using the right shift operator >>. Let's take a simple number - 64 - and divide it by 32:
+Dzięki temu możemy ustawiać i czyścić dowolne bity, a także kompresować struktury danych na ogromną skalę. Kompresja struktur danych to dobra rzecz, ponieważ jeśli używasz mniej pamięci, masz mniej cache misses, a twój kod po prostu działa szybciej. Jakby to ująć, co jest szybsze: kopiowanie 32 MB danych czy 4 MB? Cóż, z całą pewnością 4 jest szybsze. Jeśli więc możesz zmieścić wszystkie swoje flags w jednym dostępie do pamięci, to dobrze!
+Przyjrzyjmy się teraz, w jaki sposób wykonuje się dzielenie i dlaczego jest ono tak przydatne. Dzielenie wykonuje się przez przesunięcie bitów w prawo za pomocą operatora przesunięcia w prawo >>. Weźmy prostą liczbę - 64 - i podzielmy ją przez 32:
64 / 32 = 01000000 >> 5 = 00000010
-So there you shift the single bit down by 5 (which is the number of shifts required for 32 – look above), which gives us 2. But what happens if here are other bits in there? Well let's take a look:
+W tym przypadku przesuwamy pojedynczy bit w dół o 5 (tyle właśnie przesunięć potrzeba do uzyskania liczby 32 - patrz wyżej), co daje nam 2. Ale co się stanie, jeśli w tym miejscu są inne bity? Przyjrzyjmy się temu:
68 / 32 = 01000100 >> 5 = 00000010
-So there you go…. It's exactly the same. The bits we shift down are simply lost. This is actually really useful, because when dividing down if we need the remainder, there's an even easier way to get it, which we'll get to in a moment. But first, let's take a practical example. I have an X and Y position, and I want to get the grid cell this falls in, where the grid is 32x32 in size. This method allows is to store objects, collisions, flags – all manner of things, and access them very quickly. So here we go:
+No i proszę: .... Jest dokładnie tak samo. Bity, które przesuwamy w dół, są po prostu tracone. Jest to bardzo przydatne, ponieważ przy dzieleniu w dół, jeśli potrzebujemy reszty, istnieje jeszcze prostszy sposób na jej uzyskanie, o czym za chwilę. Ale najpierw posłużmy się praktycznym przykładem. Mam pozycję X i Y i chcę uzyskać komórkę siatki, w której się ona znajduje, przy czym siatka ma rozmiar 32x32. Metoda ta umożliwia przechowywanie danych objects, kolizje, flags - wszelkiego rodzaju rzeczy - i bardzo szybki dostęp do nich. A więc zaczynamy:
var X_index = x >> 5;
var Y_index = y >> 5;
cell_data = mygrid[# X_index,Y_index];
So, what if we wanted the remainder? Perhaps this remainder is used as some kind of order flag or something. Whatever the reason, getting a remainder is as simple as doing an AND:
+Co by było, gdybyśmy chcieli otrzymać resztę? Być może ta reszta jest używana jako pewnego rodzaju zamówienie flag lub coś w tym rodzaju. Niezależnie od powodu, uzyskanie reszty jest tak proste, jak wykonanie polecenia AND:
var remainder = x & 31
var X_Index = x >> 5;
Now, you might have noticed we've used multiple lines of code here (as is so often the case), but this is still only a couple of very fast instructions. But why the 31? Well, as bit 5 is 32, then all the bits below would be 31, and that's the maximum remainder so that's what we AND with (we could also use (1 << 5) - 1 which would make 32 - 1 = 31). Now, if I were to do this without understanding binary, it would look like this:
+Być może zauważyłeś, że użyliśmy tu wielu wierszy kodu (jak to często bywa), ale to wciąż tylko kilka bardzo szybkich instrukcji. Ale dlaczego 31? Ponieważ bit 5 ma wartość 32, to wszystkie bity poniżej będą miały wartość 31, a to jest maksymalna reszta, więc z taką właśnie resztą wchodzimy na stronę AND (moglibyśmy też użyć (1 << 5) - 1, co dałoby 32 - 1 = 31). Gdybym miał to zrobić, nie rozumiejąc zasad działania binarnego, wyglądałoby to tak:
var r = x mod 32;
var X_Index = floor(x / 32);
So why is this much worse? Well, in order to divide by 32, we have to execute a floating point divide - which obviously takes time, but in order to do the mod 32, you actually have to do another one! If we were doing this in assembler, we actually get BOTH values in one divide, but you don't get this in high level languages (well… not very often), and so you have to do all the work twice. This adds up, especially if you're doing a tight loop with lots of calculations like this. Integer divides using bit shifting as shown above really help optimising your game.
-Since this can be quite a complex concept to grasp and then apply to real-world programming situations, you can find below a series of short examples that could be applied to any game made with GameMaker.
- +Dlaczego więc jest to o wiele gorsze? Otóż, aby podzielić przez 32, musimy wykonać dzielenie zmiennoprzecinkowe - co oczywiście zajmuje czas, ale aby wykonać mod 32, trzeba wykonać jeszcze jedno dzielenie! Gdybyśmy robili to w asemblerze, otrzymalibyśmy obie wartości w jednym dzieleniu, ale w językach wysokiego poziomu nie jest to możliwe (cóż... niezbyt często), więc trzeba wykonać całą pracę dwukrotnie. Jest to bardzo uciążliwe, zwłaszcza jeśli na stronie loop wykonuje się wiele takich obliczeń. Dzielenie liczb całkowitych z wykorzystaniem przesunięcia bitowego, jak pokazano powyżej, naprawdę pomaga w optymalizacji gry.
+Ponieważ pojęcie to może być dość skomplikowane do zrozumienia, a następnie zastosowania w rzeczywistych sytuacjach programistycznych, poniżej znajdziesz serię krótkich przykładów, które można zastosować w dowolnej grze stworzonej za pomocą GameMakera.
+GameMaker developers often use the function place_free(), and then when a collision is found, try to slowly move the object out by either looping around an x or y position while continuing to execute that function, or by using the move_outside_all() function.
-So, what's the faster way to do this? Well, if we use proper power-of-2 tiles, then we have a very simple method that's also lightning fast. If we are moving right, and we've moved into a collision block, then as we know everything is aligned to 32, so we need to also align the sprite to a 32 pixel boundary - preferably the one to the left - so the sprite is moved OUT of the collision. This is really easy, knowing the rules we've used above to get the remainder, and knowing how to get the inverse of bits, we can simply do this:
+ProgramiściGameMakera często używają funkcji place_free(), a następnie po wykryciu kolizji próbują powoli przesunąć stronę object na zewnątrz, wykonując pętlę wokół pozycji x lub y, kontynuując wykonywanie tej funkcji, albo używając funkcji move_outside_all().
+Jaki jest więc szybszy sposób na wykonanie tej operacji? Cóż, jeśli użyjemy odpowiedniej potęgi 2 tiles, to mamy bardzo prostą metodę, która jest jednocześnie błyskawiczna. Jeśli poruszamy się w prawo i weszliśmy w blok kolizji, to jak wiemy, wszystko jest wyrównane do 32, więc musimy również wyrównać adres sprite do granicy 32 pikseli - najlepiej tej po lewej stronie - tak aby adres sprite został przesunięty poza obszar kolizji. Jest to naprawdę proste, ponieważ znając zasady, których użyliśmy powyżej do uzyskania reszty, oraz wiedząc, jak uzyskać odwrotność bitów, możemy po prostu wykonać tę czynność:
x = x & ~31;
-That's right, that's ALL that it takes to align to a 32 pixel boundary. By changing the 31 we can align to anything we like – as long as it's a power of 2. (This is the equivalent of dividing by 32, then multiplying by 32, thereby removing the lower bits.)
-If we wanted to align to the right, then we'd do the above, but then add 32 to move it into the next tile. Simple. All this makes the whole collision code monumentally faster, and lets you spend the CPU time where you really need it.
-+
Zgadza się, to WSZYSTKO, co jest potrzebne do wyrównania do granicy 32 pikseli. Zmieniając liczbę 31, możemy wyrównać do czegokolwiek chcemy - pod warunkiem, że jest to potęga 2. (Jest to odpowiednik dzielenia przez 32, a następnie mnożenia przez 32, co powoduje usunięcie niższych bitów).
+Jeśli chcemy wyrównać do prawej, wykonujemy powyższą czynność, ale dodajemy 32, aby przesunąć ją na następną stronę tile. Proste. Wszystko to sprawia, że cały kod kolizji jest znacznie szybszy i pozwala wykorzystać czas procesora tam, gdzie jest on naprawdę potrzebny.
+
Say you have a level with a few doors, and a key for each. How can you easily mark a key for a specific door? Well, normally you'd just assign an ID to the key and the door. So what if you wanted a key to open 2 or 3 doors? Easy. You use a MASK. The door would have a single bit assigned like so:
-
Załóżmy, że masz poziom z kilkoma drzwiami i kluczem do każdego z nich. W jaki sposób można łatwo oznaczyć klucz do konkretnych drzwi? Cóż, normalnie wystarczy przypisać identyfikator do klucza i drzwi. A jeśli chcesz, aby jeden klucz otwierał 2 lub 3 drzwi? To proste. Używasz MASKI. Drzwi będą miały przypisany jeden bit w następujący sposób:
+
door_id = 1; // 0001
-The others would be something like:
-
Inne to na przykład:
+
door_id=2; // 0010
door_id=4; // 0100
door_id=8; // 1000
etc...
If we wanted the key to open door 1 and 3, then the key would have the MASK value of 5 (which is 101 in binary). If we perform an AND of this, and it comes out "not zero", then we know that the key can open the door. You could also have keys that opened nothing by having a MASK of 0. See the code below for the actual check:
+Gdybyśmy chcieli, aby klucz otwierał drzwi 1 i 3, wówczas klucz miałby wartość MASK równą 5 (czyli 101 w systemie binarnym). Jeśli sprawdzimy to na stronie AND i wyjdzie nam "nie zero", to wiemy, że klucz może otworzyć drzwi. Można też mieć klucze, które nic nie otwierają, mając wartość MASK równą 0. Zobacz poniższy kod, aby sprawdzić, jak to działa:
if ((key_id & door_id) ! = 0)
{
opendoor();
}
+
Let's say we want a simple animation counter, going from 0 to to 15 (as we have 16 frames of animation). Normally you would do an increment, and then do an if check to wrap the number, but for this example let's use the AND(&) operator:
+Załóżmy, że chcemy mieć prosty licznik animacji, od 0 do 15 (ponieważ mamy 16 klatek animacji). Normalnie wykonalibyśmy inkrementację, a następnie sprawdzenie if, aby zawinąć liczbę, ale w tym przykładzie użyjmy operatora AND(&):
counter = (counter + 1) & 15;
-Since 16 is a power of 2, we can reduce that number by 1 and use it as a mask, which we can then use to wrap our counter value. If the counter moves up from 15 to 16, we end up with bit pattern 10000, and if we AND that with 15 (bit pattern 01111) we end up with 00000 (simply zero). This means that the above code is useful for wrapping values within the range of a power of 2.
-+
Ponieważ 16 jest potęgą 2, możemy zmniejszyć tę liczbę o 1 i użyć jej jako maski, którą następnie możemy wykorzystać do zawijania wartości naszego licznika. Jeśli licznik przesunie się w górę z 15 do 16, to otrzymamy bitowy wzorzec 10000, a jeśli AND to z 15 (bitowy wzorzec 01111), to otrzymamy 00000 (po prostu zero). Oznacza to, że powyższy kod jest przydatny do zawijania wartości w zakresie potęgi 2.
+
What if you wanted to check to see if something was a power of 2? Well, here's a neat little trick.. This will return true if the given value is a power of 2:
+A gdybyś chciał sprawdzić, czy coś jest potęgą dwójki? Oto mała, zgrabna sztuczka... Funkcja zwróci wynik true, jeśli podana wartość jest potęgą 2:
function is_pow2(_val)
{
return _val & (_val - 1)) == 0;
}
So if we had the number 51 (110011) what does this do? Well, we get this... 110011 & 110010, which obviously leaves us with false, as there are lots of bits left after the AND. If we had 64 (1000000), then it becomes this... 1000000 & 0111111 which does leave us 0, so it's true.
-+
Jeśli więc mamy liczbę 51 (110011), co to oznacza? Cóż, otrzymamy to... 110011 & 110010 co oczywiście pozostawia nam false, ponieważ po AND pozostało jeszcze wiele bitów. Jeśli mielibyśmy 64 (1000000), to otrzymalibyśmy to... 1000000 & 0111111, co jednak pozostawia nam 0, więc jest to true.
+
Here's a quick bit of code to align to power of 2 numbers. (1,2,4,8,16 and so on). This can be very useful for memory allocation, or making sure you write data to proper boundaries. In this example, _val1 needs to be aligned to _val2 bytes, where _val2 is a power of 2 number. This little function rounds UP to the next boundary of the desired number.
+Oto krótki fragment kodu do wyrównywania do potęgi 2 liczb. (1,2,4,8,16 i tak dalej). Może to być bardzo przydatne podczas alokacji pamięci lub upewniania się, że dane są zapisywane w odpowiednich granicach. W tym przykładzie adres _val1 musi być wyrównany do _val2 bajtów, gdzie _val2 jest potęgą liczby 2. Ta mała funkcja zaokrągla w górę do następnej granicy żądanej liczby.
function align_pow2(_val1, _val2)
{
return _val1 + (_val2 - 1)) & ~(_val2 - 1);
}
-
+
+
-
-
+
+
+
-
When you are importing a project from a previous version of GameMaker you may see that the project has compatibility scripts added. In general, these scripts use the updated GameMaker Language (GML) functions - to convert obsolete functions into the new way of doing things, and are a great way to learn how things should be done in GameMaker. However, there are a few functions that are used for compatibility only that should not be used - anywhere else, and certainly not in your own projects. To help you identify these compatibility functions they are listed here, but we must stress that they should never be used outside of compatibility scripts:
+Podczas importowania projektu z poprzedniej wersji GameMaker możesz zauważyć, że do projektu zostały dodane skrypty zgodności. Ogólnie rzecz biorąc, te skrypty scripts używają zaktualizowanych funkcji GameMaker Language (GML) + do konwersji przestarzałych funkcji na nowy sposób robienia rzeczy i są świetnym sposobem na nauczenie się, jak powinno się to robić w GameMakerze. Istnieje jednak kilka funkcji, które są używane wyłącznie w celu zapewnienia kompatybilności i nie powinny być używane + nigdzie indziej, a już na pewno nie w swoich własnych projektach. Aby ułatwić Ci identyfikację tych funkcji, wymieniono je tutaj, ale musimy podkreślić, że nigdy nie należy ich używać poza skryptami kompatybilności:
-
-
+
+
+
-
For those users coming from previous versions of GameMaker, it may be a bit confusing using GameMaker at first since there have been a number of changes made to the way that project assets, editing and coding are handled. These changes mean - that the neither the IDE nor the GameMaker Language (GML) supports the items listed below. However, that does not mean that you - cannot import games made with previous versions into GameMaker, as you can. GameMaker will automatically convert all legacy functions into compatibility scripts, which are scripts containing functions that convert - the legacy methods into the updated methods.
-What happens is that GameMaker will parse your project for all the obsolete functions and variables that you have used, and then create a series of scripts using those function names. These scripts will contain either the new equivalent - runtime function or a short script function that performs the same action as the obsolete function.
-When you first import a GameMaker project you will be shown a compatibility report much like this one:
-
The main body of the report shows which objects and scripts have been affected and where, while at the end
- you can find a list of the scripts that have been created for your project. You can click the middle mouse button 
or press 
on any of the scripts listed in the report to open it and see what has been done.
Note that if you see any scripts created with a double under-bar before their name (for example: __global_object_depths), then these are scripts that have been created by the IDE to help with compatibility and are not scripts - that have been converted from obsolete functions, so these should not be tampered with as they are required for the other compatibility scripts to work.
-When you have finished revising the compatibility report you can close the workspace, but should you need to revise anything within the report you can find it again by going to the Notes section of the - Asset Browser.
-Note that you can keep using these compatibility scripts just as you would have used the functions in the legacy version of GameMaker, however, due to the way they work, there will be a performance impact associated with this. We recommend that you - update projects to directly use the new methods and remove the compatibility scripts if you can, as it will improve performance and also give you an insight into the way that GameMaker and the GameMaker Language works compared to legacy products.
-Also note that there are some functions that have been introduced to the GameMaker Language to ensure compatibility with older projects and that will appear in these compatibility scripts. However these functions should never be used in your own projects. - You can find a list of these functions from the following section of the manual:
+Użytkownicy korzystający z poprzednich wersji programu GameMaker mogą być na początku nieco zdezorientowani, ponieważ w GameMakerze wprowadzono szereg zmian w sposobie obsługi projektu assets, edycji i kodowania. Zmiany te oznaczają, że + że ani IDE, ani język GameMaker Language (GML) nie obsługują elementów wymienionych poniżej. Nie oznacza to jednak, że + że nie możesz importować do programu GameMaker gier stworzonych w poprzednich wersjach, ponieważ możesz. GameMaker automatycznie przekształci wszystkie starsze funkcje w skrypty zgodności, które są scripts zawierające funkcje konwertujące + które konwertują starsze metody na metody zaktualizowane.
+GameMaker sprawdzi projekt pod kątem wszystkich przestarzałych funkcji i zmiennych, których używałeś, a następnie utworzy serię stron scripts z nazwami tych funkcji. Te scripts będą zawierać albo nowy odpowiednik + lub krótką funkcję skryptu, która wykonuje to samo działanie, co przestarzała funkcja.
+Podczas pierwszego importowania projektu GameMakera zostanie wyświetlony raport zgodności, podobny do tego:
+W głównej części raportu pokazano, które strony objects i scripts zostały dotknięte i gdzie, a na końcu
+ znajduje się lista stron scripts, które zostały utworzone dla danego projektu. Aby otworzyć raport i zobaczyć, co zostało zrobione, można kliknąć środkowy przycisk myszy
lub nacisnąć przycisk
na dowolnej stronie scripts wymienionej w raporcie.
Zwróć uwagę, że jeśli zobaczysz stronę scripts z podwójną kreską przed nazwą (na przykład: __global_object_depths), to są to skrypty scripts, które zostały utworzone przez IDE w celu zapewnienia kompatybilności, a nie skrypty + które zostały przekonwertowane z przestarzałych funkcji, więc nie należy w nie ingerować, ponieważ są one wymagane do działania innych kompatybilnych scripts.
+Po zakończeniu zmiany raportu zgodności można zamknąć stronę workspace, ale jeśli zajdzie potrzeba zmiany czegokolwiek w raporcie, można to ponownie znaleźć, przechodząc do sekcji Uwagi w + Przeglądarka zasobów.
+Należy pamiętać, że można nadal używać tych funkcji scripts tak samo, jak w starszej wersji GameMaker, jednak ze względu na sposób ich działania będzie to miało wpływ na wydajność. Zalecamy, aby + zaktualizować projekty tak, by bezpośrednio korzystały z nowych metod i usunąć kompatybilność scripts, jeśli to możliwe, ponieważ poprawi to wydajność, a także da Ci wgląd w sposób, w jaki działa GameMaker i GameMaker Language w porównaniu ze starszymi produktami.
+Należy również pamiętać, że istnieją pewne funkcje, które zostały wprowadzone do GameMaker Language w celu zapewnienia kompatybilności ze starszymi projektami i które pojawią się w tej kompatybilności scripts. Funkcji tych nie należy jednak nigdy używać we własnych projektach. + Listę tych funkcji można znaleźć w następującej części podręcznika:
-You can also find a complete list of all the obsolete functions that have equivalent compatibility scripts created for them from the following page:
+Na poniższej stronie znajduje się również pełna lista wszystkich przestarzałych funkcji, dla których utworzono odpowiedniki kompatybilności scripts:
--
-
+
+
+
-
This section covers all the errors you may get for your game's GML code.
-The first form of error reporting is the Syntax Error. This is an error in your code that GameMaker has caught before you have tried to compile it and these will be shown in the IDE, either in the code editor or in the Syntax Errors Output Window:
-
The next level of error reporting is the Compiler Error. These types of errors are more general than runner errors and may be due to some subtle error in the game code, which cause the it crash while it's Compiling, before it even gets a chance to run. These too will be reported in the Compiler Errors Output Window:
If the game compiles and an error occurs, you'll get a Runner Error. This type of error will show an onscreen message, much like the one shown below:
Most runner error messages follow the same outline, with a message stating the type of error, the instance and event in which the error was encountered, then a series of runner details that explain the error in a lot more depth and, finally, a list of all the declared global, instance and local variables in your game at that point. At the very bottom is the Abort button which will abort the game, as well as the Copy button (which copies the error into the clipboard) and the Clear button which clears the error messages from the window. The information provided by the error reporting here is very important as it detects and reports the large, syntax related bugs that are going to cause your finished game to crash, but note that it won't report more subtle bugs, nor does it give feedback on performance... for that you need to use the Debugger.
The following pages outline all the different Syntax, Runner, and Compiler errors that you can get and what they mean:
+Pierwszą formą zgłaszania błędów jest błąd składni. Jest to błąd w kodzie, który GameMaker wyłapał przed próbą kompilacji i który zostanie wyświetlony na stronie IDE, w edytorze kodu lub w oknie wyjściowym Syntax Errors Output Window:
+Kolejnym poziomem raportowania błędów jestBłąd kompilatora. Tego typu błędy są bardziej ogólne niż błędy runnera i mogą być spowodowane jakimś subtelnym błędem w kodzie gry, który powoduje awarię podczas kompilacji, zanim gra zdąży się uruchomić. Również one zostaną zgłoszone w oknie wyjściowym Błędy kompilatora:
Jeśli gra skompiluje się i wystąpi błąd, pojawi się Błąd runnera. Ten typ błędu spowoduje wyświetlenie na ekranie komunikatu, podobnego do pokazanego poniżej:
Większość komunikatów o błędach runnera ma ten sam schemat: komunikat określający typ błędu, instancję i zdarzenie, w którym błąd został napotkany, następnie szereg szczegółów runnera, które dokładniej wyjaśniają błąd, a na końcu listę wszystkich zadeklarowanych zmiennych globalnych, instancyjnych i lokalnych w grze w danym momencie. Na samym dole znajduje się przycisk Przerwij , który przerywa grę, a także przycisk Kopiuj (który kopiuje błąd do schowka) oraz przycisk Wyczyść , który usuwa komunikaty o błędach z okna. Informacje dostarczane przez funkcję raportowania błędów są bardzo ważne, ponieważ wykrywa ona i zgłasza duże błędy związane ze składnią, które mogą spowodować awarię gotowej gry, ale należy pamiętać, że nie zgłasza ona bardziej subtelnych błędów ani nie informuje o wydajności.
Na kolejnych stronach opisano różne błędy składni, programu uruchamiającego i kompilatora, które mogą wystąpić, oraz ich znaczenie:
-
-
+
+
+
-
The second type of error that can be reported for your game is the compiler error. A compiler error happens when your game encounters some type of error that the syntax checker may not have been able to detect - it's very easy to forget to declare a variable or mistakenly type a string as a real, for example - or when an error is related to how you have set up the compile tools from the Platform Preferences for the target platform. These errors will be caught by GameMaker as the game is being compiled and this information will also be shown in the Compiler Error Output, as shown below:
+Drugim typem błędu, który może być zgłoszony dla Twojej gry jest błąd kompilatora. Błąd kompilatora pojawia się, gdy Twoja gra napotka jakiś rodzaj błędu, którego nie był w stanie wykryć system sprawdzania składni - bardzo łatwo jest zapomnieć o zadeklarowaniu zmiennej lub omyłkowo wpisać string jako real, na przykład - lub gdy błąd jest związany z tym, jak ustawiłeś narzędzia kompilacji z Preferencji Platformy dla platformy docelowej. Błędy te zostaną wychwycone przez GameMakera w trakcie kompilacji gry, a informacja o nich pojawi się również w Compiler Error Output, jak pokazano poniżej:
NOTE These errors don't usually pop up a window and will simply show "Build Failed" in the compiler output. If a window pops up it's usually a Runner Error, which is explained here.
-The compiler error messages will all follow the same format:
+UWAGA Te błędy zazwyczaj nie wyskakują w oknie i po prostu pokażą "Build Failed" w wyjściu kompilatora. Jeśli pojawi się okno, jest to zwykle błąd biegacza, który jest wyjaśniony tutaj.
+Wszystkie komunikaty o błędach kompilatora będą miały ten sam format:
[object] - [event] - [Line Number]: [error string]
-If the error is found in a script then it will simply be:
+Jeśli błąd zostanie znaleziony w script to po prostu będzie:
[script] - [Line Number]: [error string]
-You can then double-click 
on any of the compiler error entries to open the given asset at the position flagged as giving the error, and then you can use the information contained within the message to pinpoint exactly where in the object or script the error has occurred. However, sometimes these errors can seem a bit cryptic, so below you can find a complete list of all errors and a brief explanation of what they mean:
+
Możesz wtedy dwukrotnie kliknąć na dowolnym wpisie błędu kompilatora, aby otworzyć daną asset w miejscu oznaczonym jako dające błąd, a następnie możesz użyć informacji zawartych w komunikacie, aby dokładnie określić, w którym miejscu object lub script wystąpił błąd. Jednak czasami te błędy mogą wydawać się nieco tajemnicze, więc poniżej znajdziesz pełną listę wszystkich błędów i krótkie wyjaśnienie, co one oznaczają:
| Error | -Description | +Błąd | +Opis |
|---|---|---|---|
|
- Miscellaneous +Różne |
|||
| No program to compile | -A previous compile error has caused the compiler parse tree to not be created and thus the compiler has no program data to compile | +Brak programu do kompilacji | +Poprzedni błąd kompilacji spowodował, że drzewo parsowania kompilatora nie zostało utworzone, a więc kompilator nie ma danych programu do kompilacji |
| Fatal Error while compiling [name] - bailing details below | -This message simply means that some error has been discovered but the compiler cannot place what or where (if this happens consistently you may wish to contact support and supply the details that the compiler output window shows) | +Ta wiadomość oznacza po prostu, że jakiś błąd został wykryty, ale kompilator nie może określić co i gdzie (jeśli to się dzieje konsekwentnie, możesz chcieć skontaktować się z pomocą techniczną i dostarczyć szczegóły, które pokazuje okno wyjściowe kompilatora) | |
| Recursive macro expansion is not supported | -You have used recursive macros that refer to each other and constantly expand | +Rekursywne rozszerzanie makr nie jest obsługiwane | +Użyłeś rekurencyjnych makr, które odwołują się do siebie i stale rozszerzają |
| Unable to find TextureGroup [group] | -This error is usually only found from trying to run a malformed project file (if this happens consistently you may wish to contact support and supply the details that the compiler output window shows) | +Nie można znaleźć TextureGroup [group] | +Ten błąd jest zwykle spotykany tylko przy próbie uruchomienia źle sformułowanego pliku projektu (jeśli zdarza się to konsekwentnie, możesz chcieć skontaktować się z pomocą techniczną i dostarczyć szczegóły, które pokazuje okno wyjściowe kompilatora) |
| Wrong to convert [value] to number | -You have tried to convert the given value, for example a string, into a number | +Błędna konwersja [value] na liczbę | +Próbowałeś zamienić podaną wartość, np. string, na liczbę |
| Division by 0 | -You have tried to divide a value by 0 | +Podział przez 0 | +Próbowałeś podzielić wartość przez 0 |
| Invalid object id [object ID] used | -You have tried to access an object using an ID value that is incorrect | +Użyto nieprawidłowego identyfikatora object [object ID] | +Próbowałeś uzyskać dostęp do strony object używając nieprawidłowej wartości ID. |
| Unclosed comment (/*) at end of script | -You have created a script comment using - /* [comment] */ - but have not supplied the closing comment tag + | Niezamknięty komentarz (/*) na końcu skryptu | +Utworzyłeś komentarz script używając + /* [comment] */ + ale nie dostarczyłeś zamykającego tagu komentarza |
| Invalid token | -You have an invalid character in your game code, which can happen with foreign language characters or Unicode | +Nieważny token | +Masz nieprawidłowy znak w kodzie gry, co może się zdarzyć w przypadku znaków obcojęzycznych lub Unicode |
| Number [num] in incorrect format | -The given number - shown in the error - is not the correct format for the function or operation being performed, for example you supply an integer when a pointer is required | +Numer [num] w nieprawidłowym formacie | +Podana liczba - pokazana w błędzie - nie jest prawidłowym formatem dla wykonywanej funkcji lub operacji, np. podajesz liczbę całkowitą, gdy wymagany jest wskaźnik |
| Unexpected EOF encountered | -You have reached the end of file unexpectedly while using the File Functions | +Napotkano nieoczekiwane EOF | +Nieoczekiwanie osiągnąłeś koniec pliku podczas korzystania z funkcji plików |
|
- Strings +Struny |
|||
| Unable to Not a string | -You have tried to use "!" (not) on a string | +Nie można Not a string | +Próbowałeś użyć "!" (nie) na ciągu znaków |
| Unable to Negate a string | -You have tried to negate a string, for example + | Nie można zanegować ciągu znaków | +Próbowałeś zanegować string, np. string = -string |
|
- Scripts, Functions and Arguments +Skrypty, Funkcje i argumenty |
|||
| Wrong number of arguments for function [function] | -You have supplied too many or too few arguments for the given function | +Niewłaściwa liczba argumentów dla funkcji [function] | +Podałeś zbyt wiele lub zbyt mało argumentów dla danej funkcji |
| Failed to parse action_execute_script() - incorrect number of arguments received | -The GML Visual action Execute Script has too many or too few arguments for the given script being called | +Failed to parse action_execute_script() - nieprawidłowa liczba otrzymanych argumentów | +Akcja wizualna GML Execute Script ma zbyt wiele lub zbyt mało argumentów dla wywoływanego script |
| Unknown function [function] check to see if script is empty | -A script or function has been called that the compiler does not recognise (this error is usually thrown by empty script asset references since the compiler will strip out these assets on compile) | +Nieznana funkcja [function] sprawdź, czy script jest pusta | +Wywołana została strona script lub funkcja, której kompilator nie rozpoznaje (ten błąd jest zwykle powodowany przez puste odwołania script asset, ponieważ kompilator usuwa te assets podczas kompilacji) |
| Function [function] expects n arguments, a provided | -A function has been given the wrong number of arguments (n) when a certain number were expected (a) | +Funkcja [function] oczekuje argumentów n, a dostarczonych | +Funkcja otrzymała niewłaściwą liczbę argumentów (n), gdy oczekiwano określonej liczby (a) |
| Assignment of an empty value (function does not return anything?) | -You have tried to assign a return value from a function when that function returns nothing | +Przypisanie pustej wartości (funkcja nic nie zwraca?) | +Próbowałeś przypisać wartość zwrotną z funkcji, gdy ta funkcja nic nie zwraca |
| Unable to find function [function] | -You have called an unknown function | +Nie można znaleźć funkcji [function] | +Wywołałeś nieznaną funkcję |
| Calling a function that needs an instance and no instance is available | -The function or script being called is for acting on an instance, but at the time of running no instances exist | +Wywołanie funkcji, która wymaga instancji, a żadna instancja nie jest dostępna | +Wywoływana funkcja lub script służy do działania na instancji, ale w momencie jej uruchomienia nie istnieją żadne instancje |
| Calling a function that needs an other and no other is available | -You have used the keyword other outside of the Collision Event or outside of a with statement | +Wywołanie funkcji, która potrzebuje innego, a żaden inny nie jest dostępny | +Użyłeś słowa kluczowego other poza wydarzeniem kolizyjnym lub poza wypowiedzią with. |
| Argument naming error, n arguments but no reference found to a | -You have given a number of arguments to a script, but fail to reference one of them in the script, for example, your script takes three arguments but you only use arguments n and a | +Błąd nazwy argumentu, n argumenty, ale nie znaleziono odniesienia do a | +Podałeś kilka argumentów do script, ale nie odwołałeś się do jednego z nich w script, na przykład twój script przyjmuje trzy argumenty, ale używasz tylko argumentów n i a |
| Cannot compare arguments | -You have tried to compare two different argument types, like a string and a real number | +Nie można porównać argumentów | +Próbowałeś porównać dwa różne typy argumentów, takie jak string i liczba rzeczywista |
| Unknown function or script [functions/script] | -The compiler does not recognise the function or script being called | +Nieznana funkcja lub script [functions/script] | +Kompilator nie rozpoznaje wywoływanej funkcji lub script |
| Cannot use resource name [resource] as it is not being exported | -You have tried to access a resource that has not been flagged as part of the project for the platform being compiled to | +Nie można użyć nazwy zasobu [resource] , ponieważ nie jest on eksportowany | +Próbowałeś uzyskać dostęp do zasobu, który nie został oznaczony jako część projektu dla platformy, na którą jest kompilowany |
| Cannot use function/script name for a variable, using [functions/script] | -You have tried to use either a function name or a script name as a variable, for example: + | Nie można użyć nazwy funkcji/skryptu dla zmiennej, używając [functions/script] | +Próbowałeś użyć nazwy funkcji lub nazwy script jako zmiennej, na przykład: string = "Hello World" |
| Cannot use an argument outside a script | -The built in argument variables can only be used inside a script but you have tried to use them elsewhere | +Nie można użyć argumentu poza skryptem | +Wbudowane zmienne argumentów mogą być używane tylko wewnątrz script, ale próbowałeś użyć ich gdzie indziej |
| No references to argument[num] but references argument[num] | -You are using a reference to an argument that does not exist but that could map to another argument | +Brak odniesień do argument[num], ale odniesienia argument[num] | +Używasz odniesienia do argumentu, który nie istnieje, ale który mógłby mapować do innego argumentu |
| Incorrect number of arguments for accessor | -You have supplied the wrong number of arguments when using an accessor | +Nieprawidłowa liczba argumentów dla accessora | +Podałeś niewłaściwą liczbę argumentów podczas używania akcesora |
| Wrong type of arguments for (one of the below): - /, div, mod, +, -, &&, ||, &, |, ^, <<, >> |
- You have supplied the wrong type of argument for the expression being evaluated | +Zły typ argumentów dla (jednego z poniższych): + /, div, mod, +, -, &&, ||, &, ^, <<, >>. |
+ Podałeś niewłaściwy typ argumentu dla ocenianego wyrażenia |
|
- Variables +Zmienne |
|||
| Using uninitialized variable [var] | -You have tried to use the named variable before it has been initialised | +Użycie niezainicjowanej zmiennej [var] | +Próbowałeś użyć nazwanej zmiennej przed jej inicjalizacją |
| Variable [var] is read-only | -You have tried to change the named variable when it cannot be changed | +Zmienna [var] jest tylko do odczytu | +Próbowałeś zmienić nazwaną zmienną, gdy nie można jej zmienić |
| Unable to find variable named [var] | -The named variable cannot be found in the current compile | +Nie można znaleźć zmiennej o nazwie [var] | +Nazwana zmienna nie może być znaleziona w bieżącej kompilacji |
| Malformed variable reference | -You have tried to reference a variable in the wrong way | +Nieprawidłowe odniesienie do zmiennej | +Próbowałeś odwołać się do zmiennej w niewłaściwy sposób |
| Trying to set a read only variable [var] | -You have tried to set a variable that is read only | +Próba ustawienia zmiennej tylko do odczytu [var] | +Próbowałeś ustawić zmienną, która jest tylko do odczytu |
| Cannot re-declare a built in variable | -You have tried to declare a local variable using the same name as one of the built in variables | +Nie można ponownie zadeklarować zmiennej wbudowanej | +Próbowałeś zadeklarować zmienną lokalną używając tej samej nazwy co jedna z wbudowanych zmiennych |
| Cannot use resource name for a variable | -You have use the same name as a resource from the resource tree as a local variable | +Nie można użyć nazwy zasobu dla zmiennej | +Możesz użyć tej samej nazwy co zasób z drzewa zasobów jako zmiennej lokalnej |
| [Variable] is read-only | -You have tried to use a variable that has been flagged as read only | +[Zmienna] jest tylko do odczytu | +Próbowałeś użyć zmiennej, która została oznaczona jako tylko do odczytu |
|
- Constants +Stałe |
|||
| Cannot set a constant [constant] to a value | -You have tried to set a constant to a different value | +Nie można ustawić na wartość stałej [constant] | +Próbowałeś ustawić stałą na inną wartość |
| Constant is invalid here | -You have tried to use a constant somewhere that is not valid for the code being run | +Stała jest tu nieważna | +Próbowałeś użyć gdzieś stałej, która nie jest ważna dla uruchamianego kodu |
| Cannot assign to [var] - it's a constant | -You have tried to assign a new value to the named constant | +Nie można przypisać do [var] - jest to stała | +Próbowałeś przypisać nową wartość do nazwanej stałej |
|
- Arrays +Tablice |
|||
| Array index should not be negative | -You have tried to access, create, or set an array value using a negative array index | +Indeks tablicy nie powinien być ujemny | +Próbowałeś uzyskać dostęp, utworzyć lub ustawić wartość tablicy przy użyciu ujemnego indeksu tablicy |
|
- Malformed... +Malformacja... |
|||
| Malformed Conditional operator | -You have used an erroneous conditional (ternary) operator or if statement, and not the format: + | Nieprawidłowo sformułowany operator warunkowy | +Użyłeś błędnego operatora warunkowego (trójskładnikowego) lub if statement, a nie formatu: [condition] ? [expression1] : [expression2]; |
| If requires a then statement | -You have written an if statement and expression to evaluate, but not given any then part to run | +Jeśli wymaga oświadczenia then | +Napisałeś if statement i wyrażenie do oceny, ale nie podałeś żadnej części do uruchomienia |
| malformed assignment statement | -In the code you are using an assignment operator wrong | +nieprawidłowo sformułowane oświadczenie o przypisaniu | +W kodzie używasz operatora przypisania błędnie |
| Malformed - if / repeat / while / do / for / with / switch / break / continue / exit - statement |
- The structure of the given statement is incorrect. | +Zniekształcona + if / repeat / while / do / for / with / switch / break / continue / exit + oświadczenie |
+ Struktura podanej wypowiedzi jest nieprawidłowa. |
| Malformed post inc or dec statement | -You have tried to use [var]++ or [var]-- in an illegal way | +Nieprawidłowe oświadczenie post inc lub dec | +Próbowałeś używać [var]++ lub [var]-- w sposób nielegalny. |
| Malformed pre inc or dec statement | -You have tried to use ++[var] or --[var] in an illegal way | +Nieprawidłowo sformułowana deklaracja pre inc lub dec | +Próbowałeś używać ++[var] lub --[var] w sposób nielegalny. |
| Malformed global gml_pragma | -You have created a wrong global string when using gml_pragma | +Niewłaściwa globalna gml_pragma | +Stworzyłeś błędny globalny string podczas używania gml_pragma |
| Malformed PNGCrush gml_pragma | -You have created a wrong string command for PNGCrush when using gml_pragma | +Nieformalny PNGCrush gml_pragma | +Stworzyłeś złe polecenie string dla PNGCrush podczas używania gml_pragma |
| Malformed Texgroup.Scale gml_pragma | -You have create a wrong global string when using gml_pragma | +Złe sformułowanie Texgroup.Scale gml_pragma | +Stworzyłeś błędny globalny string podczas używania gml_pragma |
@@ -291,87 +291,87 @@ Compile Errors |
|||
| Default cannot be used multiple times in a switch | -In your switch statement you have defined default: more than once | +Default nie może być używany wielokrotnie w przełączniku | +W twoim oświadczeniu switch zdefiniowałeś domyślne: więcej niż raz |
| Clause expression type mismatch (clause expressions should all be the same type) | -In your switch you are checking for two different constant case types, for example a string in one case and an integer in another | +Niedopasowanie typu wyrażenia klauzuli (wszystkie wyrażenia klauzuli powinny być tego samego typu) | +W twoim switch sprawdzasz dla dwóch różnych stałych typów przypadków, na przykład string w jednym przypadku i liczba całkowita w innym |
| Case argument should be a constant | -You have tried to use a value that does not evaluate to a constant within one of your switch cases | +Argumentacja w sprawie powinna być stała | +Próbowałeś użyć wartości, która nie jest stała w jednym z twoich przypadków switch |
| Statement in a switch MUST appear after case or default | -You have added a statement to a switch outside of either a case: or default: call | +Oświadczenie na stronie switch MUSI pojawić się po literze "case" lub "default". | +Dodałeś deklarację do switch poza wywołaniem case: lub default: |
| Duplicate case statement found / original here | -You have used the same case constant in two different places within a switch (note that the "original here" comment will be on another line and can be clicked to show the original case) | +Znaleziono duplikat oświadczenia w sprawie / oryginał tutaj | +Użyłeś tej samej stałej przypadku w dwóch różnych miejscach w ramach switch (zauważ, że komentarz "oryginalny tutaj" będzie w innej linii i może być kliknięty, aby pokazać oryginalny przypadek.) |
|
- Expressions +Wyrażenia |
|||
| No return value from expression (does expression have a return value?) | -You have tried to assign a return value from an expression to a variable when the expression returns nothing | +Brak wartości zwrotnej z wyrażenia (czy wyrażenie ma wartość zwrotną?) | +Próbowałeś przypisać wartość zwracaną z wyrażenia do zmiennej, gdy wyrażenie nic nie zwraca |
| Expecting expression after the '.' | -You have used the point "." notation erroneously and not added an expression afterwords correctly | +Oczekiwanie wyrażenia po ". | +Błędnie użyłeś notacji punktowej "." i nie dodałeś poprawnie wyrażenia po słowach |
| Unexpected symbol [symbol] in expression | -The expression uses a symbol that is not part of the accepted expression symbol set - the symbol in question will be shown | +Nieoczekiwany symbol [symbol] w wyrażeniu | +W wyrażeniu użyto symbolu, który nie jest częścią akceptowanego zestawu symboli wyrażenia - symbol ten zostanie pokazany |
|
- Unknown Operators +Nieznani operatorzy |
|||
| Unknown Pre operator | -You have tried to use a symbol as a pre-operator when that symbol is not permitted, for example **[var] or >>[var] - only ++ and -- are acceptable | +Nieznany operator wstępny | +Próbowałeś użyć symbolu jako preoperatora, gdy ten symbol jest niedozwolony, na przykład **[var] lub >>[var] - dopuszczalne są tylko ++ i -- |
| Unknown Post operator | -You have tried to use a symbol as a post-operator when that symbol is not permitted, for example [var]** or [var]>> - only ++ and -- are acceptable | +Nieznany operator poczty | +Próbowałeś użyć symbolu jako post-operatora, gdy ten symbol jest niedozwolony, na przykład [var]** lub [var]>> - dopuszczalne są tylko ++ i -- |
| Unknown pragma [gml_pragma string] | -You have used a pragma string that is unknown to the compiler | +Nieznana pragma [gml_pragma string] | +Użyłeś pragmy string, która nie jest znana kompilatorowi |
| Unknown unary operator | -You have tried to use an unknown symbol as a unary operator | +Nieznany operator jednoargumentowy | +Próbowałeś użyć nieznanego symbolu jako operatora jednoargumentowego |
| Unknown binary operator | -You have tried to use an unknown symbol as a binary operator | +Nieznany operator binarny | +Próbowałeś użyć nieznanego symbolu jako operatora binarnego |
| Unknown operator [operator] | -You have tried to use an unknown symbol as an operator (the symbol will be shown in the error) | +Nieznany operator [operator] | +Próbowałeś użyć nieznanego symbolu jako operatora (symbol będzie pokazany w błędzie) |
|
- Break / Continue +Przerwa / Kontynuacja |
|||
| Break used without context | -You have not used break within a switch or a loop or any other permitted structure | +Przerwa użyta bez kontekstu | +Nie użyłeś break w ramach switch lub loop lub innej dozwolonej struktury |
| Continue used without context | -You have not used continue within the correct context | +Kontynuacja użyta bez kontekstu | +Nie użyłeś continue w odpowiednim kontekście |
| continue statement is not allowed at this point | -You have used continue within a apart of your code where it is not permitted | +kontynuowanie wypowiedzi nie jest w tym momencie dozwolone | +Użyłeś continue w części swojego kodu, gdzie jest to niedozwolone |
@@ -379,67 +379,67 @@ Compile Errors |
|||
| enum num is invalid | -The enum number is invalid for the enum | +enum num jest niepoprawne | +Numer enum jest nieprawidłowy dla enum |
| malformed enum | -You have not created the enum correctly | +zniekształcony enum | +Nie utworzyłeś poprawnie enum |
| enum [enum] has already been defined | -You have tried to define an enum using the same name as another previously defined | +enum [enum] zostało już zdefiniowane | +Próbowałeś zdefiniować enum używając tej samej nazwy, co inne wcześniej zdefiniowane |
| malformed enum entry | -The enum has an invalid entry | +nieprawidłowy wpis enum | +Liczba ma niepoprawny wpis |
| enum expression must be an integer constant | -The enum entry does not evaluate as an integer constant | +wyrażenie enum musi być stałą całkowitą | +Wpis enum nie jest obliczany jako stała całkowita. |
| enum reference [key] does not exist in [enum] | -You have tried to reference an enum entry using a key that has not previously been defined for that enum | +Odwołanie do enum [key] nie istnieje w [enum] | +Próbowałeś odwołać się do wpisu enum używając klucza, który nie został wcześniej zdefiniowany dla tego enum |
|
- Expected Symbols / Values +Oczekiwane symbole / wartości |
|||
| Symbol ( expected - Symbol ) expected - Symbol , or ) expected - Symbol { expected - Symbol } expected - Symbol , or } expected - Symbol : expected - Symbol ; expected - Symbol [ expected - symbol ] expected - Symbol , or ] expected |
- You have not used a required symbol when writing your code | +Symbol ( oczekiwany + Symbol ) oczekiwany + Symbol , lub ) oczekiwany + Symbol { oczekiwany + Symbol } oczekiwany + Symbol , lub } oczekiwany + Symbol : oczekiwany + Symbol ; oczekiwany + Symbol [ oczekiwany + symbol ] oczekiwany + Symbol , lub ] oczekiwany |
+ Nie użyłeś wymaganego symbolu podczas pisania swojego kodu |
| Expected id or string | -You have used a value that is not either a layer ID or a layer name - as a string - in one of the Layer functions | +Oczekiwane id lub ciąg znaków | +W jednej z funkcji warstwy użyłeś wartości, która nie jest ani identyfikatorem warstwy, ani nazwą warstwy - jako string. |
| keyword Until expected | -You have created a do... until loop but neglected to supply an until expression | +słowo kluczowe Do czasu, gdy spodziewano się | +Stworzyłeś do... until loop ale zaniedbałeś dostarczenie wyrażenia until |
| Function name expected | -You have used something other than a function name in your code where a function should go | +Oczekiwana nazwa funkcji | +Użyłeś czegoś innego niż nazwa funkcji w swoim kodzie, gdzie powinna być funkcja |
| variable name expected | -You have supplied a name that is not a variable name where one is expected | +oczekiwana nazwa zmiennej | +Podałeś nazwę, która nie jest nazwą zmiennej tam, gdzie jest ona oczekiwana |
| Assignment operator expected | -You have created an assignment which expects an operator but none has been supplied | +Oczekiwany operator przypisania | +Utworzyłeś zadanie, które oczekuje operatora, ale żaden nie został dostarczony |
@@ -447,20 +447,20 @@ Compile Errors |
|||
| Android ARM ToolChain directory [dir] does not exist | -The link given in the Android Preferences for the ARM toolchain is incorrect and does not exist. | +Android ARM Nie istnieje katalog ToolChain [dir] | +Link podany w Android Preferences dla ARM toolchain jest nieprawidłowy i nie istnieje. |
| Android MIPS ToolChain directory [dir] does not exist | -The link given in the Android Preferences for the MIPS toolchain is incorrect and does not exist. | +Nie istnieje katalog Android MIPS ToolChain [dir] | +Link podany w Android Preferences dla MIPS toolchain jest nieprawidłowy i nie istnieje. |
| Android x86 ToolChain directory [dir] does not exist | -The link given in the Android Preferences for the x86 toolchain is incorrect and does not exist. | +Nie istnieje katalog Android x86 ToolChain [dir] | +Link podany w Android Preferences dla toolchaina x86 jest nieprawidłowy i nie istnieje. |
| Android NDK directory [dir] does not exist | -The link given in the Android Preferences for the Android NDK is incorrect and does not exist. | +Katalog Android NDK [dir] nie istnieje | +Link podany w Preferencjach Android dla Android NDK jest nieprawidłowy i nie istnieje. |
@@ -468,22 +468,22 @@ Compile Errors |
|||
| Configuration Problem : Windows Visual Studio Path needs to be set to point to Visual Studio (.bat) batch file. | -The link given in the Windows Preferences for the Visual Studio (.bat) batch file is incorrect and does not exist. | +Problem konfiguracyjny : Windows Visual Studio Path musi być ustawiony tak, aby wskazywał na plik wsadowy Visual Studio (.bat). | +Link podany w Preferencjach Windows dla pliku wsadowego Visual Studio (.bat) jest nieprawidłowy i nie istnieje. |
-
-
+
+
+
-
Even after syntax checking in the code editor and then having the compiler check your code for compiler errors, there are still occasions when something can go wrong. In most cases this will throw a Virtual Machine (VM) runner error (also called a runtime exception) which looks like this:
-
- Runner errors are generally more serious than compile errors as it means that there is something seriously wrong with your code that neither the code editor nor the compiler have been able to detect, and as such you should pay attention to all such errors. When one occurs, you can use the Copy button on the pop-up to copy the error to the clipboard which you can then paste into a text file (or wherever) for future reference.
-The structure of this error is as follows:
+Nawet po sprawdzeniu składni w edytorze kodu, a następnie sprawdzeniu kodu pod kątem błędów przez kompilator, nadal zdarzają się sytuacje, w których coś może pójść nie tak. W większości przypadków spowoduje to wyświetlenie błędu runnera maszyny wirtualnej (zwanego również wyjątkiem runtime), który wygląda tak:
+Błędy uruchamiania są na ogół poważniejsze niż błędy kompilacji, ponieważ oznaczają, że w kodzie jest coś poważnego, czego nie udało się wykryć ani edytorowi kodu, ani kompilatorowi, dlatego należy zwracać uwagę na wszystkie takie błędy. W przypadku wystąpienia takiego błędu można użyć przycisku Kopiuj w wyskakującym okienku, aby skopiować błąd do schowka, który można następnie wkleić do pliku tekstowego (lub gdziekolwiek indziej) w celu wykorzystania w przyszłości.
Struktura tego błędu jest następująca:
As mentioned above, certain error messages will be identify the scope not by an instance ID value, but rather by a negative value. These values can be used to pinpoint the exact nature of the error and what it refers to with the following values possible:
+Jak wspomniano powyżej, niektóre komunikaty o błędach będą identyfikować zakres nie za pomocą wartości ID instancji, ale raczej za pomocą wartości ujemnej . Wartości te można wykorzystać do dokładnego określenia natury błędu oraz tego, do czego się odnosi, korzystając z następujących możliwych wartości:
| Prefix | -Scope | +Prefiks | +Zakres |
|---|---|---|---|
| -1 | @@ -42,11 +39,11 @@|||
| -2 | -Other | +Inne | |
| -3 | -All | +Wszystkie | |
| -4 | @@ -58,47 +55,35 @@|||
| -6 | -Not Specified | +Nie określono. | |
| -7 | -Local | +Lokalna strona |
-
The possible errors from the VM runner are as follows:
++
Możliwe błędy występujące w VM runnerze są następujące:
| Error | -Message | -Operation | -Description | +Błąd | +Wiadomość | +Operacja | +Opis |
|---|---|---|---|---|---|---|---|
| DoSet | -Invalid comparison type | -Data Types | -This denotes that the runner has tried to compare two incompatible data types, like a real number with a string. | +Nieprawidłowy typ porównania | +Typy danych | +Oznacza to, że biegacz próbował porównać dwa niekompatybilne typy danych, np. liczbę rzeczywistą z liczbą string. | |
| DoConv | -Execution Error | -Data Types | -This denotes an error in the conversion of one data-type into another. | -||||
| Argument Type | -(function) argument (index) incorrect type (wrong_type) expecting a (expected_type) | -Data Types | -A value with the wrong data type was passed as an argument to the function at (index) (where an index of 1 is the first argument). A value of wrong_type was given but it should be one of expected_type instead. | +Błąd wykonania | +Typy danych | +Oznacza to błąd w konwersji jednego typu danych na inny. | |
@@ -107,57 +92,57 @@ Runner Errors | |||||||
| DoAdd | -Execution Error | -Maths | -Something has gone wrong when using the addition (+) expression. | +Błąd wykonania | +Matematyka | +Coś poszło nie tak podczas używania wyrażenia dodawania (+). | |
| DoMul | -Execution Error | -Maths | -Something has gone wrong when using the multiplication (*) expression. | +Błąd wykonania | +Matematyka | +Coś poszło nie tak podczas używania wyrażenia mnożenia (*). | |
| DoSub | -Execution Error | -Maths | -Something has gone wrong when using the subtraction (-) expression. | +Błąd wykonania | +Matematyka | +Coś poszło nie tak podczas używania wyrażenia odejmowania (-). | |
| DoSub | -Execution Engine - Cannot operate on string type | -Maths | -You are trying to subtract the wrong type of variables (for example subtract a string from a real). | +Silnik wykonawczy - nie można operować na typie string | +Matematyka | +Próbujesz odejmować zmienne niewłaściwego typu (np. odjąć string od rzeczywistej). | |
| DoDiv | -Execution Error | -Maths | -Something has gone wrong when using the division (/ or div) expression. | +Błąd wykonania | +Matematyka | +Coś poszło nie tak podczas używania wyrażenia dzielenia (/ lub div). | |
| DoDiv | -Execution Engine - Cannot operate on string type | -Maths | -You are trying to divide the wrong type of variables (for example divide a string by a real). | +Silnik wykonawczy - nie można operować na typie string | +Matematyka | +Próbujesz dzielić zmienne niewłaściwego typu (np. dzielić string przez rzeczywistą). | |
| DoDiv | -Divide by zero | -Maths | -You are attempting to divide by 0 (note this will only happen when using integer division, dividing a (non-zero) real by 0 will give infinity as an answer, dividing zero by zero will give NaN as an answer). You can check for these values with (is_infinity) and (is_nan) | +Podzielić przez zero | +Matematyka | +Próbujesz podzielić przez 0 (zauważ, że dzieje się tak tylko wtedy, gdy używasz dzielenia przez liczby całkowite, dzielenie (niezerowej) liczby rzeczywistej przez 0 da w wyniku nieskończoność, a dzielenie zera przez zero da w wyniku NaN). Można sprawdzić te wartości za pomocą (is_infinity) i (is_nan) | |
| DoMod | -Execution Error | -Maths | -Something has gone wrong when using the modulo (mod) expression. | +Błąd wykonania | +Matematyka | +Coś poszło nie tak podczas używania wyrażenia modulo (mod). | |
| DoMod | -Execution Engine - Cannot operate on string type | -Maths | -You are trying to use modulo (mod) on the wrong type of variables (for example mod a string by a real). | +Silnik wykonawczy - nie można operować na typie string | +Matematyka | +Próbujesz użyć funkcji modulo (mod) na zmiennych niewłaściwego typu (na przykład mod a string przez rzeczywistą). | |
@@ -166,63 +151,63 @@ Runner Errors | |||||||
| DoAnd | -Execution Error | +Błąd wykonania | Bitwise | -Something has gone wrong when using the bitwise "and" (&) expression. | +Coś poszło nie tak podczas używania wyrażenia bitowego "i" (&). | ||
| DoAnd | -Execution Engine - Cannot operate on string type | +Silnik wykonawczy - nie można operować na typie string | Bitwise | -You are trying to use bitwise "and" (&) on the wrong type of variables (for example trying to "and" a string with a real). | +Próbujesz użyć bitowego "i" (&) na zmiennych niewłaściwego typu (na przykład próbujesz "i" string z liczbą rzeczywistą). | ||
| DoOr | -Execution Error | +Błąd wykonania | Bitwise | -Something has gone wrong when using the bitwise "or" (|) expression. | +Coś poszło nie tak podczas używania wyrażenia bitowego "lub" (|). | ||
| DoOr | -Execution Engine - Cannot operate on string type | +Silnik wykonawczy - nie można operować na typie string | Bitwise | -You are trying to use "or" (|) on the wrong type of variables (for example trying to "or" a string with a real). | +Próbujesz użyć "lub" (|) na zmiennych niewłaściwego typu (na przykład próbujesz "lub" string z real). | ||
| DoXor | -Execution Error | +Błąd wykonania | Bitwise | -Something has gone wrong when using the bitwise "xor" (^) expression. | +Coś poszło nie tak podczas używania wyrażenia bitowego "xor" (^). | ||
| DoXor | -Execution Engine - Cannot operate on string type | +Silnik wykonawczy - nie można operować na typie string | Bitwise | -You are trying to use "xor" (^) on the wrong type of variables (for example trying to "xor" a string with a real). | +Próbujesz użyć funkcji "xor" (^) na zmiennych niewłaściwego typu (na przykład próbujesz "xorować" zmienną string z rzeczywistą). | ||
| DoShl | -Execution Error | +Błąd wykonania | Bitwise | -Something has gone wrong when bitshifting left (<<) a value. | +Coś poszło nie tak podczas przesuwania bitów w lewo (<<) wartości. | ||
| DoShl | -Execution Engine - Cannot operate on string type | +Silnik wykonawczy - nie można operować na typie string | Bitwise | -You are trying to left bitshift (<<) the wrong type of variables (for example trying to bitshift a string). | +Próbujesz przesunąć w lewo (<<) zmienne niewłaściwego typu (na przykład próbujesz przesunąć w lewo zmienną string). | ||
| DoShr | -Execution Error | +Błąd wykonania | Bitwise | -Something has gone wrong when bitshifting right (>>) a value. | +Coś poszło nie tak podczas przesuwania bitów w prawo (>>) wartości. | ||
| DoShr | -Execution Engine - Cannot operate on string type | +Silnik wykonawczy - nie można operować na typie string | Bitwise | -You are trying to right bitshift (>>) the wrong type of variables (for example trying to bitshift a string). | +Próbujesz przesunąć w prawo (>>) zmienne niewłaściwego typu (na przykład próbujesz przesunąć w prawo zmienną string). | ||
@@ -231,15 +216,15 @@ Runner Errors | |||||||
| DoNeg | -Execution Error | -Negate | -You are trying to turn a variable type into a negative when this type does not permit such an operation. | +Błąd wykonania | +Neguj | +Próbujesz zamienić zmienną typu na ujemną, gdy ten typ nie pozwala na taką operację. | |
| DoNot | -Execution Error | -Negate | -You are trying to "not" a variable type when this type does not permit such an operation. | +Błąd wykonania | +Neguj | +Próbujesz "nie" typu zmiennej, gdy ten typ nie pozwala na taką operację. | |
@@ -248,27 +233,27 @@ Runner Errors | |||||||
| Push | -Execution Error - Variable Index out of range (var) | -Stack | -The variable being accessed is out with the established range for the runner. | +Błąd wykonania - Indeks zmiennej poza zakresem (var) | +Stos | +Zmienna, do której uzyskuje się dostęp, znajduje się poza ustalonym zakresem dla biegacza. | |
| Push | -Variable Get (var) | -Stack | -The given variable has not been defined or is unknown. | +Zmienna Uzyskaj (var) | +Stos | +Podana zmienna nie została zdefiniowana lub jest nieznana. | |
| Pop | -Variable Index out of range (var) | -Stack | -The variable being accessed is out with the established range for the runner. | +Zmienna Indeks poza zakresem (var) | +Stos | +Zmienna, do której uzyskuje się dostęp, znajduje się poza ustalonym zakresem dla biegacza. | |
| Pop | -Variable Get (var) | -Stack | -The given variable has not been defined or is unknown. | +Zmienna Uzyskaj (var) | +Stos | +Podana zmienna nie została zdefiniowana lub jest nieznana. | |
@@ -277,9 +262,9 @@ Runner Errors | |||||||
| With | -Cannot use global in with statement | -With | -You have tried to use "global" as a variable within a "with" statement, ie: + | Nie można użyć wartości globalnej w wyrażeniu with | +Z | +Próbowałeś użyć "global" jako zmiennej w oświadczeniu "with", tzn: with (global) { //do something; @@ -288,9 +273,9 @@ Runner Errors | |
| With | -Cannot use local in with statement | -With | -You have tried to use "local" as a variable within a "with" statement, ie: + | Nie można użyć local w wyrażeniu with | +Z | +Próbowałeś użyć "local" jako zmiennej w oświadczeniu "with", tzn: with (local) { //do something; @@ -304,44 +289,32 @@ Runner Errors | |
| DoCall | -Execution Engine type error | -Engine | -This is an undefined error within the Virtual Machine. You should file a bug report should this happen (see: The Help Menu for details on how to do this. | +Błąd typu silnika wykonawczego | +Silnik | +Jest to błąd undefined występujący w maszynie wirtualnej. W takim przypadku należy zgłosić błąd (szczegółowe informacje na ten temat znajdują się w: Menu Pomoc. | |
| Stack Overflow | - | -Engine | -A stack overflow occurs when too much memory is used on the call stack and when your game attempts to use more space than is available on the call stack (that is, when it attempts to access memory beyond the call stack's bounds, which is essentially a buffer overflow), the stack is said to overflow, resulting in a program crash. Restart your computer and GameMaker and if the error persists please get in touch with support and/or file a bug (as explained above). | -||||
|
- - |
- |||||||
| Read Variable | -Variable not set before reading it | -Variable Initialisation | -You are trying to access a variable that hasn't been set (i.e. initialised) yet. Assign a value to it first before trying to read it, e.g. variable = 100;. Only declaring a variable, using e.g. var variable; will also throw this error. | +Silnik | +Przepełnienie stosu ma miejsce, gdy na stosie wywołań znajduje się zbyt dużo pamięci i gdy Twoja gra próbuje wykorzystać więcej miejsca, niż jest dostępne na stosie wywołań (to znaczy, gdy próbuje uzyskać dostęp do pamięci poza granicami stosu wywołań, co jest zasadniczo przepełnieniem buffer ), mówi się, że stos się przepełnia, co powoduje awarię programu. Uruchom ponownie komputer i GameMakera, a jeśli błąd będzie się powtarzał, skontaktuj się z działem pomocy technicznej i/lub zgłoś błąd (jak opisano powyżej). | ||
-
-
+
+
+
-
The first level of error reporting when programming your games in GameMaker is in the code or GML Visual editor, and it's the syntax checker. As you write your code - or add your actions - GameMaker will check that it follows the established syntax for the language, and flag any issues that it finds so you can fix them before it comes to running the game or compiling an executable.
-Syntax error checking happens differently depending on whether you have enabled Feather in the Feather Settings.
-Pierwszy poziom raportowania błędów podczas programowania gier w GameMakerze znajduje się w edytorze kodu lub GML Visual, a jest nim sprawdzanie składni. Gdy piszesz swój kod - lub dodajesz swoje akcje - GameMaker sprawdza, czy jest on zgodny z ustaloną składnią dla danego języka i flag wszelkie problemy, które znajdzie, abyś mógł je naprawić zanim dojdzie do uruchomienia gry lub kompilacji pliku wykonawczego.
+Sprawdzanie błędów składniowych przebiega inaczej w zależności od tego, czy włączyłeś Feather w Ustawieniach Feather.
+
These errors fall into two main categories:
+Błędy te dzielą się na dwie główne kategorie:
Warnings: These are shown for things that may be an error, but may not be, and probably won't stop the game from compiling, but might provoke runtime errors. The most common causes of these warnings is when a variable is used in an expression and it hasn't been defined yet anywhere else, or when a variable has been defined but hasn't been used.
Errors: These are problems that will not permit the game to compile, let alone run. These should be fixed before doing anything further with the code. The table below shows the most common causes of these.Syntax errors will update as you write your code (there will be a short pause between typing something and any errors appearing in this window to prevent errors being reported for unfinished code), and will follow the format:
+Błędy składniowe będą aktualizowane w miarę pisania kodu (pomiędzy wpisaniem czegoś a pojawieniem się błędów w tym oknie będzie krótka przerwa, aby zapobiec zgłaszaniu błędów dla niedokończonego kodu), i będą zgodne z formatem:
[object] - [event] - [Line Number] - [Position In Line]: [error string]
-Or if the error is in a script, it will be:
+Albo jeśli błąd jest w script, to będzie:
[script] - [Line Number] - [Position in line]: [error string]
-Double clicking on any of the errors shown in the output console will take you to the line in the object event or script that has the error so you can edit it.
It should be noted that some of these errors will be shown at specific places in your code, but the actual error may be cause by something elsewhere, or one single issue may provoke multiple error messages:
-
In the above image, all three errors have been provoked by a single mistake - the use of a semi colon ";" instead of a comma "," at line 220 for the function variable_instance_exists().
The table below lists the different syntax errors and their main causes:
-+
Podwójne kliknięcie na którymkolwiek z błędów pokazanych w konsoli wyjściowej przeniesie cię do linii w zdarzeniu object lub script, która ma błąd, więc możesz ją edytować.
Należy zauważyć, że niektóre z tych błędów będą wyświetlane w określonych miejscach w twoim kodzie, ale rzeczywisty błąd może być spowodowany przez coś innego, lub jeden problem może wywołać wiele komunikatów o błędach:
+Na powyższym obrazku wszystkie trzy błędy
zostały sprowokowane przez jeden błąd - użycie średnika ";" zamiast przecinka "," w linii 220 dla funkcji variable_instance_exists().
Poniższa tabela zawiera listę różnych błędów składni i ich głównych przyczyn:
+
| Error | -Type | -Description | +Błąd | +Typ | +Opis |
|---|---|---|---|---|---|
| Malformed reference [val] | - |
- This means there is an internal AST Validation Error (you should never see this error, but if you do please consider filing a bug report from the Help Menu) | + |
+ Oznacza to, że wystąpił wewnętrzny błąd walidacji AST (nie powinieneś nigdy zobaczyć tego błędu, ale jeśli tak się stanie, rozważ zgłoszenie błędu z menu Pomoc) | |
| Malformed hexadecimal character escape sequence | +Niewłaściwa sekwencja ucieczki znaków szesnastkowych | |
- This can happen when you have used the hexadecimal value for an escape character in a string and this has the wrong format. | +Może się to zdarzyć, gdy użyłeś wartości szesnastkowej dla znaku ucieczki w string i ma to niewłaściwy format. | |
| Unexpected node [val] | - |
- This means there is an internal AST Validation Error (you should never see this error, but if you do please consider filing a bug report from the Help Menu) | +Nieoczekiwany węzeł [val] | + |
+ Oznacza to, że wystąpił wewnętrzny błąd walidacji AST (nie powinieneś nigdy zobaczyć tego błędu, ale jeśli tak się stanie, rozważ zgłoszenie błędu z menu Pomoc) |
| Exception while parsing [val] | - |
- This means there is an internal AST Validation Error (you should never see this error, but if you do please consider filing a bug report from the Help Menu) | +Wyjątek podczas parsowania [val] | + |
+ Oznacza to, że wystąpił wewnętrzny błąd walidacji AST (nie powinieneś nigdy zobaczyć tego błędu, ale jeśli tak się stanie, rozważ zgłoszenie błędu z menu Pomoc) |
| Malformed id reference [val] | |
- + | |||
| Unnecessary expression [val] used as a statement | +Niepotrzebne wyrażenie [val] użyte jako stwierdzenie | |
- This error occurs when the syntax checker detects an expression (shown in [val]) where it was expecting a statement. For example, the following code will throw the error as it's expecting the ternary operator ? but encounters 32: + | Ten błąd pojawia się, gdy sprawdzacz składni wykryje wyrażenie (pokazane w [val]), gdzie spodziewał się oświadczenia. Na przykład, następujący kod rzuci błąd, ponieważ oczekuje operatora trójskładnikowego ? ale napotyka 32: temp_x = x < (room_width / 2) 32: room_width - 32; |
|
| Malformed array reference [val] | |
- This means you have tried to reference an array in an incorrect way, and [val] will show the reference. | +Oznacza to, że próbowałeś odwołać się do tablicy w nieprawidłowy sposób, a [val] pokaże to odniesienie. | ||
| Unexpected binary operator [val] | +Nieoczekiwany operator binarny [val] | |
- This error occurs when you use one of the bitwise operators in a place where it shouldn't be getting used, with [val] showing where. | +Ten błąd występuje, gdy używasz jednego z operatorów bitowych w miejscu, w którym nie powinien być używany, z [val] pokazując, gdzie. | |
| Unterminated string literal | +Nie zakończone string dosłowne | |
- This error will occur when you open a string using @“ or “ but you do not close it before the end of code. | +Ten błąd pojawi się, gdy otworzysz stronę string za pomocą @“ lub “, ale nie zamkniesz jej przed końcem kodu. | |
| Single quotes no longer allowed for string | +Pojedyncze cudzysłowy nie są już dozwolone dla łańcuchów | |
- This error occurs when you try to use strings wrapped in single quotes, eg: 'Hello World', instead of double quotes, eg: "Hello World". | +Ten błąd pojawia się, gdy próbujesz użyć strings zawiniętego w pojedyncze cudzysłowy, np. "Hello World", zamiast podwójnych cudzysłowów, np. | |
| Unexpected syntax error | +Nieoczekiwany błąd składni | |
- This error denotes a syntax error which the parser is not able to identify more specifically. | +Ten błąd oznacza błąd składni, którego parser nie jest w stanie dokładniej zidentyfikować. | |
| Got "[val1]", expected "[val2]" | +Otrzymano "[val1]", oczekiwano "[val2]" | |
- This happens when the syntax checker expects some value or symbol but gets a different one, where [val1] is the current symbol or value, and [val2] is the expected symbol or value. For example: + | Dzieje się tak, gdy sprawdzacz składni oczekuje jakiejś wartości lub symbolu, ale dostaje inną, gdzie [val1] jest bieżącym symbolem lub wartością, a [val2] jest oczekiwanym symbolem lub wartością. Na przykład: Got "{", expected "(" |
|
| Got "[val1]", expected "[val2]" or "[val3]" | +Otrzymano "[val1]", oczekiwano "[val2]" lub "[val3]" | |
- As above, but for when there are multiple possible expected symbols. | +Jak wyżej, ale dla sytuacji, gdy istnieje wiele możliwych oczekiwanych symboli. | |
| Expected expression | +Oczekiwane wyrażenie | |
- This error occurs when the syntax checker expects an expression but one isn't given. | +Ten błąd pojawia się, gdy sprawdzanie składni oczekuje wyrażenia, ale nie zostało ono podane. | |
| Empty [val] statement | +Puste oświadczenie [val] | |
- This happens when you terminate a statement and leave it empty. For example, the following code will give the error (note the terminating semi-colon): + | Dzieje się tak, gdy kończysz oświadczenie i pozostawiasz je puste. Na przykład następujący kod da błąd (zwróć uwagę na kończący średnik): if (x < 0); |
|
| Nested function calls are not allowed | +Zagnieżdżone wywołania funkcji nie są dozwolone | |
- This can happen when you are trying to nest function calls within a statement, eg: + | Może się to zdarzyć, gdy próbujesz zagnieżdżać wywołania funkcji w ramach oświadczenia, np: ds_list_find_value(list, 0)).sprite_index |
|
| Number of arguments for function [val1] expected [val2] got val[3] | +Liczba argumentów dla funkcji [val1] oczekiwana [val2] got val[3] | |
- This error tells you that you have not supplied the correct number of arguments to the function shown for [val1], which expects the number shown in [val2] but got those shown in [val3]. | +Ten błąd mówi Ci, że nie podałeś prawidłowej liczby argumentów do funkcji pokazanej dla [val1], która oczekuje liczby pokazanej w [val2], ale dostała te pokazane w [val3]. | |
| Number of arguments for function [val1] expected [val2] - [val3] got [val4] | +Liczba argumentów dla funkcji [val1] oczekiwana [val2] - [val3] otrzymana [val4] | |
- As above only for a range of arguments. | +Jak wyżej tylko dla zakresu argumentów. | |
| Duplicate enum entry found | +Znaleziono duplikat wpisu enum | |
- This error tells you that you have duplicated an enum variable entry name | +Ten błąd informuje, że powielono nazwę wpisu zmiennej enum | |
| Duplicate enum found | +Znaleziono duplikat enum | |
- This error tells you that you have defined two or more enums with the same name. | +Ten błąd informuje, że zdefiniowałeś dwa lub więcej enum o tej samej nazwie. | |
| Missing variable name in globalvar | +Brakująca nazwa zmiennej w globalvar | |
- This tells you that you have used the globalvar declaration but omitted to supply a variable name. | +To mówi ci, że użyłeś deklaracji globalvar, ale pominąłeś dostarczenie nazwy zmiennej. | |
| Missing variable name in var | +Brakująca nazwa zmiennej w var | |
- This tells you that you have used the var declaration but omitted to supply a variable name. | +To mówi ci, że użyłeś deklaracji var, ale pominąłeś dostarczenie nazwy zmiennej. | |
| No matching #region found for #endregion | +Nie znaleziono pasującego #regionu dla #endregion | |
- This error means you have declared an end region in your code, without defining a start region. | +Ten błąd oznacza, że zadeklarowałeś w swoim kodzie region końcowy, bez zdefiniowania regionu początkowego. | |
| Unclosed #region found at end of script | +Niezamknięty #region znaleziony na końcu skryptu | |
- This error means you have declared a region somewhere in the code but have not defined an end region anywhere for it. | +Ten błąd oznacza, że zadeklarowałeś region gdzieś w kodzie, ale nie zdefiniowałeś dla niego nigdzie regionu końcowego. | |
| Unexpected terminal operator [val] | +Nieoczekiwany operator terminala [val] | |
- This means there is an internal AST Validation Error (you should never see this error, but if you do please consider filing a bug report from the Help Menu) | +Oznacza to, że wystąpił wewnętrzny błąd walidacji AST (nie powinieneś nigdy zobaczyć tego błędu, ale jeśli tak się stanie, rozważ zgłoszenie błędu z menu Pomoc) | |
| Unexpected unary operator [val] | +Nieoczekiwany operator jednoargumentowy [val] | |
- This happens when a unary operator (like +, -, =, etc...) has been found in your code at a place when it isn't expected, where [val] will show you the operator. | +Dzieje się tak, gdy operator jednoargumentowy (jak +, -, =, itd...) został znaleziony w twoim kodzie w miejscu, w którym nie jest oczekiwany, gdzie [val] pokaże ci ten operator. | |
| Unexpected ternary operator [val] | +Nieoczekiwany operator trójskładnikowy [val] | |
- This error means you have used one of the parts of the ternary operator incorrectly somewhere in your code, where [val] shows the part that is in error. | +Ten błąd oznacza, że gdzieś w swoim kodzie użyłeś niepoprawnie jednej z części operatora trójskładnikowego, gdzie [val] wskazuje część, która jest w błędzie. | |
| Try needs to have catch or finally clause | +Próba musi mieć klauzulę catch lub finally | |
- This error means you have called the try function but have omitted to include a catch or finally clause. | +Ten błąd oznacza, że wywołałeś funkcję try, ale pominąłeś włączenie klauzuli catch lub finally. | |
| Macro [val] already exists | +Makro [val] już istnieje | |
- You can get this error when you try to define a macro [val] with the same name as one that has been previously defined. | +Ten błąd możesz otrzymać, gdy próbujesz zdefiniować makro [val] o tej samej nazwie, co makro, które zostało wcześniej zdefiniowane. | |
| Malformed variable reference, got [val] | |
- This means there is an internal AST Validation Error (you should never see this error, but if you do please consider filing a bug report from the Help Menu) | +Oznacza to, że wystąpił wewnętrzny błąd walidacji AST (nie powinieneś nigdy zobaczyć tego błędu, ale jeśli tak się stanie, rozważ zgłoszenie błędu z menu Pomoc) | ||
| Assignment to multi-relational-equality expression - GML does not support multiple assignments in an expression | +Przypisanie do wyrażenia typu multi-relational-equality - GML nie obsługuje wielu przypisań w wyrażeniu | |
- This error tells you there is an issue with a multi-operator assignment (also called a compound assignment) which is not supported by the GameMaker Language. This includes things like "*=" or "/=", etc... | +Ten błąd informuje, że występuje problem z przypisaniem wielu operatorów (zwanym również przypisaniem złożonym), które nie jest obsługiwane przez GameMaker Language. Obejmuje to rzeczy takie jak "*=" lub "/=", itp. | |
| Macro [val] is unused | - |
- This happens when the macro [val] is unused anywhere in your code. | +Makro [val] jest nieużywane | + |
+ Dzieje się tak, gdy makro [val] jest nieużywane w dowolnym miejscu twojego kodu. |
| Variable [val] only referenced once | - |
- This means that the given variable [val] is only referenced once in your code. | +Zmienna [val] ma tylko jedno odniesienie | + |
+ Oznacza to, że dana zmienna [val] jest tylko raz przywoływana w twoim kodzie. |
| Unassigned variable [val] referenced | - |
- This means that the variable [val] has been referenced in your code, but has not been assigned a value anywhere previously. | +Odwołanie do nieprzypisanej zmiennej [val] | + |
+ Oznacza to, że zmienna [val] została przywołana w twoim kodzie, ale nigdzie wcześniej nie przypisano jej wartości. |
| Only functions that are declared as constructors can use inheritance | +Tylko funkcje, które są zadeklarowane jako konstruktory mogą używać dziedziczenia | |
- This error tells you that you have tried to use inheritance on a function which has not been declared as a constructor. | +Ten błąd mówi ci, że próbowałeś użyć dziedziczenia na funkcji, która nie została zadeklarowana jako konstruktor. | |
| Unknown function attribute [val] | +Nieznany atrybut funkcji [val] | |
- This error means that you have tried to use an invalid or unidentified function modifier ([val]) when declaring an in-kine function (a function modifier is something like the constructor keyword, which is supported). | +Ten błąd oznacza, że próbowałeś użyć nieprawidłowego lub niezidentyfikowanego modyfikatora funkcji ([val]) podczas deklarowania funkcji in-kine (modyfikator funkcji jest czymś takim jak słowo kluczowe constructor, które jest obsługiwane). | |
| Inherited argument \"[val]\" is not in function arguments | - |
- This error happens when you try to reference an argument in an inherited function that has not been declared in the parent function definition. | +Argument odziedziczony \"[val]\" nie występuje w argumentach funkcji | + |
+ Ten błąd występuje, gdy próbujesz odwołać się do argumentu w funkcji dziedziczonej, która nie została zadeklarowana w definicji funkcji nadrzędnej. |
| [val] Creation Code | - |
- This happens when you have an error [val] in the room creation code somewhere. | +Kod tworzenia [val] | + |
+ Dzieje się tak, gdy masz gdzieś błąd [val] w kodzie tworzenia room. |
When Feather is enabled the Syntax Errors window is replaced by the Feather Messages window:
-
The Feather Messages window lists the errors and warnings that Feather encounters in your code, as well as the suggestions that it gives when it finds certain specific code patterns. Which types of errors are shown here depends on the profile that you define in the Feather Settings under Message Severity.
In this window the list of messages can be sorted ascending or descending by message code, by message text (alphabetically) or by resource (alphabetically by resource name). You can also search using the search box in the top right corner of the window.
-Feather messages fall into three categories:
+Gdy Feather jest włączony, okno Syntax Errors jest zastępowane przez okno Feather Messages:
+Okno Feather Messages zawiera listę błędów i ostrzeżeń, które Feather napotyka w Twoim kodzie, jak również sugestie, które daje, gdy znajdzie pewne określone wzorce kodu. To, jakie typy błędów są tutaj pokazywane, zależy od profilu, który definiujesz w Ustawieniach Feathera w sekcji Message Severity.
W tym oknie lista wiadomości może być sortowana rosnąco lub malejąco według kodu wiadomości, według tekstu wiadomości (alfabetycznie) lub według zasobu (alfabetycznie według nazwy zasobu). Można również wyszukiwać za pomocą pola wyszukiwania w prawym górnym rogu okna.
+Wiadomości z piór dzielą się na trzy kategorie:
Warnings: These are shown for possible errors, which, in most cases, won't stop the game from compiling, but might provoke runtime errors. The most common causes of these warnings is when a variable is used in an expression and it hasn't been defined yet anywhere else, or when a variable has been defined but hasn't been used.
Errors: These are problems that will not permit the game to compile, let alone run. These should be fixed before doing anything further with the code.
Suggestions: These are suggestions for possible improvements to the code, related to a variety of things.+
-
This guide briefly covers how to build and use primitives using custom vertex formats and vertex buffers.
-In general when you start working with 3D, special effects, complex drawing processes or shaders you don't need to worry too much about the vertex format being used, since GameMaker will automatically set up and pass through the vertex data for you. However, sometimes it is necessary to create your own vertex data and format it to suit, especially when you need to boost speed, or wish to pass in extra information. For example the standard vertex format includes an x, y, z 3D position, colour (with alpha), and UV texture coordinates, which, if you were creating it yourself, would look something like:
+W tym podręczniku omówiono pokrótce sposób tworzenia i używania prymitywów przy użyciu niestandardowych formatów wierzch ołków i buforów wierzchołków.
+Na ogół, gdy zaczynasz pracę z 3D, efektami specjalnymi, złożonymi procesami rysowania lub stroną shaders, nie musisz się zbytnio przejmować używanym formatem vertex, ponieważ GameMaker automatycznie skonfiguruje i przepuści dane wierzchołków. Czasami jednak konieczne jest utworzenie własnych danych vertex i odpowiednie ich sformatowanie, zwłaszcza gdy chcesz zwiększyć szybkość lub przekazać dodatkowe informacje. Na przykład standardowy format vertex zawiera pozycję 3D x, y, z, kolor (z alfą) oraz współrzędne UV texture. Gdybyś sam tworzył takie dane, wyglądałyby one następująco
vertex_format_begin();
vertex_format_add_position_3d();
vertex_format_add_colour();
- vertex_format_add_texcoord();
+ vertex_format_add_textcoord();
my_format = vertex_format_end();
However, if you are only using (for example) a shader to manipulate the position of the vertex, then there would be no need to pass through colour or texture data. In this case you would create your own format as so:
+Jeśli jednak używasz (na przykład) adresu shader tylko do manipulowania położeniem adresu vertex, nie ma potrzeby przekazywania danych o kolorze ani adresu texture. W takim przypadku należy utworzyć własny format w następujący sposób:
vertex_format_begin();
vertex_format_add_position_3d();
my_format = vertex_format_end();
In total there are five different vertex attributes that you can use when defining a vertex format:
+W sumie istnieje pięć różnych atrybutów vertex, których można użyć podczas definiowania formatu vertex:
In general you must always provide position or 3D position as part of the format, but all the others are optional.
-You should note that once you have created your vertex format, the order in which you have defined the vertex attributes must be honoured when building your primitives. So, if you have defined a vertex format as position, colour, and texture coordinate, then you must add these attributes to the primitive in the same order otherwise you will get an error. Also note that like any other dynamic resource, a vertex format requires memory and therefore should be removed when not needed using the function vertex_format_delete.
-Any primitives that you build are held in a vertex buffer. This must be created beforehand and then referenced by the functions that are used to build your primitive. The vertex buffer can be reused as many times as necessary to create different primitives, or it can be "frozen" to maintain a specific primitive type for the duration of your game or level (which is the fastest approach, so if you know that a primitive you build will not change then you should always use this option).
-An example of a single triangle primitive being built is shown in the following code:
+Ogólnie rzecz biorąc, w formacie należy zawsze podawać pozycję lub pozycję 3D, ale wszystkie pozostałe elementy są opcjonalne.
+Należy pamiętać, że po utworzeniu formatu vertex kolejność, w jakiej zostały zdefiniowane atrybuty vertex, musi być przestrzegana podczas tworzenia prymitywów. Tak więc, jeśli zdefiniowałeś format vertex jako pozycję, kolor i współrzędną texture, musisz dodać te atrybuty do prymitywu w tej samej kolejności, w przeciwnym razie pojawi się błąd. Należy również pamiętać, że jak każdy inny zasób dynamiczny, format vertex wymaga pamięci i dlatego powinien być usuwany, gdy nie jest potrzebny, za pomocą funkcji vertex_format_delete().
+Wszystkie prymitywy, które zostaną zbudowane, są przechowywane w buforze wierzchołków. Bufor ten musi być utworzony wcześniej, a następnie odwołują się do niego funkcje używane do budowania prymitywów. Strona vertex buffer może być używana tyle razy, ile jest to konieczne do tworzenia różnych prymitywów, lub może zostać "zamrożona", aby zachować określony typ prymitywu na czas trwania gry lub poziomu (jest to najszybsze rozwiązanie, więc jeśli wiesz, że zbudowany prymityw nie ulegnie zmianie, zawsze powinieneś korzystać z tej opcji).
+Przykład budowy prymitywu pojedynczego trójkąta jest przedstawiony w poniższym kodzie:
// CREATE EVENT
v_buff = vertex_create_buffer();
vertex_begin(v_buff, global.my_format);
@@ -58,87 +58,88 @@
Here we have first created our vertex buffer in the Create Event of the instance, then we begin the definition of the different vertices that make up our triangle primitive, giving the position, the colour, and the texture UV coordinate for each of the three points that we want to use. We then end the vertex definition, and we know that the vertex buffer with this vertex data is stored in the variable "v_buff".
-If the contents of the buffer are going to be updated constantly, the buffer would be created, given the vertex data, and then be destroyed again - after it's been drawn - all in the same step.
-We then draw the contents of the vertex buffer in the Draw Event using a shader. This is a very simple example, and is basically how GameMaker works internally, ie: When you draw a sprite, GameMaker creates a vertex buffer with four vertices creating two triangles (which make a square, also called a "quad"), and textures these two triangles with the sprite image. When we draw this sprite, we are submitting the vertex buffer and its contents are drawn to the screen.
-You'll notice when we submit the vertex buffer for drawing, we supply a primitive type. The type of primitive you use can be a point, a line list or strip, or a triangle list or strip, but you are not permitted triangle fans since most mobile hardware will not accept that primitive type. Don't forget to format your vertex buffer correctly for the type of primitive that is going to be used to draw it. For example, drawing a two triangle primitive as a triangle list requires 6 points, but as a triangle strip it only requires 4 points. Which type you use is up to you and will depend on what you are wanting to draw and the effect that you want to achieve.
-One final important point to note when using your own vertex buffers in this way is how it affects the vertex batches that are sent to the GPU. When you create a vertex buffer you are creating the lowest level of graphics data, so when you draw all that happens is that GameMaker sends your buffer directly to the graphics card. Because of this, if you want better batching, you must work it out yourself and store the things you want to batch inside the same buffer.
-As we have already mentioned above, vertex formats are built up by using together the following 5 attribute types (added via the appropriate vertex_format_add_* function):
+W tym przypadku najpierw tworzymy nasz wierzchołek buffer w zdarzeniu Create Event instancji, a następnie rozpoczynamy definicję różnych wierzchołków, które tworzą nasz prymityw trójkąta, podając pozycję, kolor i współrzędną UV texture dla każdego z trzech punktów, których chcemy użyć. Następnie kończymy definicję vertex i wiemy, że strona vertex buffer z danymi vertex jest przechowywana w zmiennej "v_buff".
+UWAGA: Jeśli zawartość strony buffer ma być stale aktualizowana, można by utworzyć stronę buffer, przekazać jej dane vertex, a następnie ponownie ją zniszczyć - po narysowaniu - wszystko w tym samym kroku.
+Następnie w zdarzeniu Draw Event rysujemy zawartość strony vertex buffer za pomocą strony shader. Jest to bardzo prosty przykład i w zasadzie tak właśnie działa GameMaker, tzn. gdy rysujesz stronę sprite, strona GameMaker tworzy stronę vertex buffer z czterema wierzchołkami tworzącymi dwa trójkąty (które tworzą kwadrat, zwany też "quadem"), a strona textures tworzy z tych dwóch trójkątów obraz sprite. Podczas rysowania tej strony sprite przesyłamy na ekran obraz vertex buffer i jego zawartość.
+Po przesłaniu strony vertex buffer do narysowania podajemy typ prymitywu. Prymityw może być punktem, listą lub paskiem linii albo listą lub paskiem trójkątów, ale nie wolno używać trójkątów, ponieważ większość urządzeń przenośnych nie akceptuje tego typu prymitywów. Nie zapomnij sformatować strony vertex buffer poprawnie dla typu prymitywu, który ma być użyty do jej narysowania. Na przykład, rysowanie prymitywu dwóch trójkątów jako listy trójkątów wymaga 6 punktów, ale jako paska trójkątów wymaga tylko 4 punktów. To, którego typu użyjesz, zależy od tego, co chcesz narysować i jaki efekt chcesz osiągnąć.
+Ostatnią ważną kwestią, na którą należy zwrócić uwagę, używając w ten sposób własnej strony vertex buffers, jest to, jak wpływa ona na partie wierzchołków wysyłane do GPU. Gdy tworzysz vertex buffer, tworzysz najniższy poziom danych graficznych, więc podczas rysowania wszystko, co się dzieje, to fakt, że GameMaker wysyła buffer bezpośrednio do karty graficznej. Z tego powodu, jeśli chcesz uzyskać lepszy podział na partie, musisz to zrobić samodzielnie i przechowywać elementy, które chcesz podzielić na partie, w tej samej witrynie buffer.
+Jak już wspomniano powyżej, formaty vertex są tworzone poprzez łączne wykorzystanie następujących 5 typów atrybutów (dodawanych za pomocą odpowiedniej funkcji vertex_format_add_* ):
Within the GLSL ES shader, these kinds are recognised using the following 4 attributes:
+W języku GLSL ES shader rodzaje te są rozpoznawane za pomocą następujących 4 atrybutów:
Now, this might look odd as it seems that we can specify more attribute kinds in our vertex format than we can in the vertex shader. However, in the shader Position and 3D Position are treated as the same attribute, except that Position is expected to have only "x" and "y" coordinates whereas 3D Position has “x”, “y” and “z” coordinates. So how do you map what's in your vertex format to how you define attributes in your shader? Let's start by looking at a typical set of attributes from the default shader:
-+
Może to wyglądać dziwnie, ponieważ wydaje się, że w naszym formacie vertex możemy określić więcej rodzajów atrybutów niż w vertex shader. Jednak w formacie shader Position i 3D Position są traktowane jako te same atrybuty, z tym wyjątkiem, że Position ma mieć tylko współrzędne "x" i "y", podczas gdy 3D Position ma współrzędne "x", "y" i "z". Jak więc odwzorować to, co jest w formacie vertex, na sposób definiowania atrybutów w shader? Na początek przyjrzyjmy się typowemu zestawowi atrybutów z domyślnego shadera:
+
attribute vec3 in_Position; // (x,y,z)
//attribute vec3 in_Normal; // (x,y,z) unused in this shader.
attribute vec4 in_Colour; // (r,g,b,a)
attribute vec2 in_TextureCoord; // (u,v)
And here's a chunk of code which sets up a vertex format compatible with this shader:
+A oto fragment kodu, który ustawia format vertex kompatybilny z tym shaderem:
vertex_format_begin();
vertex_format_add_position_3d();
vertex_format_add_colour();
- vertex_format_add_texcoord();
+ vertex_format_add_textcoord();
my_format = vertex_format_end();
Now, how does the shader attribute get matched to the vertex format type? It's just based on the naming convention:
+W jaki sposób atrybut shader jest dopasowywany do typu formatu vertex? Opiera się to na konwencji nazewnictwa:
Now, things get trickier when you have multiple attributes of the same kind, but things are still based on the same naming convention. We'll look at supplying additional colour and texture coordinates now, as there can only be one Position and one Normal attribute in the shader or vertex format, but there can be multiple colour or texture attributes.
-When adding additional colour attributes to your shader, a number needs to be added to the end of the shader attribute to indicate which particular entry in the vertex format the attribute maps to. Here's an example - first the vertex format:
+Sytuacja komplikuje się, gdy mamy wiele atrybutów tego samego rodzaju, ale nadal stosujemy tę samą konwencję nazewnictwa. Przyjrzymy się teraz dostarczaniu dodatkowych współrzędnych koloru i tekstury, ponieważ w formacie shader lub vertex może być tylko jeden atrybut Pozycja i jeden atrybut Normalny, ale może być wiele atrybutów koloru lub texture.
+Podczas dodawania dodatkowych atrybutów koloru do strony shader na końcu atrybutu shader należy dodać numer wskazujący, do którego wpisu w formacie vertex atrybut ten jest przypisany. Oto przykład - najpierw format vertex:
vertex_format_begin();
vertex_format_add_position_3d();
vertex_format_add_colour();
vertex_format_add_colour();
- vertex_format_add_texcoord();
+ vertex_format_add_textcoord();
my_format = vertex_format_end();
And now the associated shader attributes:
+A teraz powiązane atrybuty shader:
attribute vec3 in_Position; // (x,y,z)
attribute vec4 in_Colour0; // (r,g,b,a)
attribute vec4 in_Colour1; // (r,g,b,a)
attribute vec2 in_TextureCoord; // (u,v)
In this case in_Colour0 maps to the first vertex_format_add_colour() and in_Colour1 maps to the second.
-Texture coordinates are handled slightly differently to colour. Basically, anything which isn't called in_Position, in_Normal or one of the in_Colour[0 ... ] attributes is treated as a texture coordinate. The order they are defined in, in the list of attributes in the shader, is what denotes which attribute in the vertex format they map to. See the following GML example:
+W tym przypadku adres in_Colour0 odpowiada pierwszemu adresowi vertex_format_add_colour(), a adres in_Colour1 odpowiada drugiemu.
+Współrzędne tekstury są traktowane nieco inaczej niż kolor. Zasadniczo wszystko, co nie ma nazwy in_Position, in_Normal lub jednego z atrybutów in_Colour[0 ... ], jest traktowane jako współrzędna texture. Kolejność, w jakiej są one zdefiniowane na liście atrybutów w witrynie shader, określa, do którego atrybutu w formacie vertex są one mapowane. Patrz następujący przykład GML:
vertex_format_begin();
vertex_format_add_position_3d();
vertex_format_add_colour();
- vertex_format_add_texcoord();
- vertex_format_add_texcoord();
- vertex_format_add_texcoord();
+ vertex_format_add_textcoord();
+ vertex_format_add_textcoord();
+ vertex_format_add_textcoord();
my_format = vertex_format_end();
And the shader code would look something like this:
+Kod shader wyglądałby mniej więcej tak:
attribute vec3 in_Position; // (x,y,z)
attribute vec4 in_Colour; // (r,g,b,a)
attribute vec2 in_myTexcoord; // (u,v)
attribute vec2 in_TextureCoord; // (u,v)
attribute vec2 in_Something; // (u,v)
In this example, in_myTexcoord, in_TextureCoord and in_Something map to the three successive texture coordinate attributes defined in the vertex format.
-You can find a full list of all the functions required to create vertex formats, vertex buffers and primitives from the following page:
+W tym przykładzie adresy in_myTexcoord, in_TextureCoord i in_Something odpowiadają trzem kolejnym atrybutom współrzędnych texture zdefiniowanym w formacie vertex.
+Pełną listę wszystkich funkcji potrzebnych do tworzenia formatów vertex, vertex buffers i prymitywów można znaleźć na następnej stronie:
--
+
+
+
-
If you've been using GameMaker for any length of time, you will almost certainly have come across blend modes, and probably even used them in your games. Blend modes are a great way to change how something is drawn to give interesting and specific graphical effects, but do you know how they work and how do you use them? This is a subject that can confuse people and so in this section we hope to dispel some of the mystery surrounding blend modes and enable you to use them to their fullest extent in your games.
--
Blend modes basically tell your game to draw certain things blended with whatever else is already drawn beforehand. Everything you draw to the screen is made up of four component parts - red, green, blue and alpha - and by default they are drawn to the screen using the blend mode bm_normal. This blend mode draws all pixels with their colour and alpha values essentially unchanged (although, later in this section you'll see that this isn't quite true...), but GameMaker has a number of built in blend modes that can be set to change this behaviour.
-When GameMaker goes to draw a pixel there's a source colour (the colour of the pixel you are going to draw) and a destination colour (the colour that's already in the pixel we're drawing to). When determining the new colour of the pixel, GameMaker will combine the source and destination colours according to the blend mode, as mentioned above. Each component of the colours is stored as a floating point value between 0 and 1, and the new colour is calculated by multiply each component of the source colour by some factor and by multiplying each component of destination colour by some other factor and then adding the results together component by component.
--
GameMaker uses the function gpu_set_blendmode() to change the blending that your game uses for drawing. You would call this before (for example) drawing a sprite, then set it back again afterwards, something like this:
+Jeśli korzystasz z GameMakera przez dłuższy czas, z pewnością zetknąłeś się z trybami mieszania, a prawdopodobnie nawet używałeś ich w swoich grach. Tryby mieszania to świetny sposób, by zmienić sposób rysowania czegoś w celu uzyskania interesujących i specyficznych efektów graficznych, ale czy wiesz, jak one działają i jak z nich korzystać? Jest to temat, który może wprawiać ludzi w zakłopotanie, dlatego w tym rozdziale mamy nadzieję rozwiać część tajemnic związanych z trybami mieszania i umożliwić ich pełne wykorzystanie w grach.
++
Tryby mieszania pozwalają grze na rysowanie pewnych elementów w połączeniu z innymi, już narysowanymi wcześniej. Wszystko, co rysujesz na ekranie, składa się z czterech części składowych - czerwonej, zielonej, niebieskiej i alfa - i domyślnie jest rysowane na ekranie przy użyciu trybu mieszania bm_normal. Ten tryb mieszania rysuje wszystkie piksele z ich kolorami i wartościami alfa w zasadzie bez zmian (choć w dalszej części tego rozdziału zobaczysz, że to nie do końca prawda...), ale GameMaker ma wiele wbudowanych trybów mieszania, które można ustawić, by zmienić to zachowanie.
+Gdy w programie GameMaker chcemy narysować piksel, mamy do dyspozycji kolor źródłowy (kolor piksela, który chcemy narysować) i kolor docelowy (kolor, który już znajduje się w pikselu, do którego rysujemy). Podczas określania nowego koloru piksela strona GameMaker połączy kolory źródłowy i docelowy zgodnie z trybem mieszania, jak wspomniano powyżej. Każdy składnik kolorów jest przechowywany jako wartość zmiennoprzecinkowa z zakresu od 0 do 1, a nowy kolor jest obliczany przez pomnożenie każdego składnika koloru źródłowego przez pewien współczynnik oraz przez pomnożenie każdego składnika koloru docelowego przez inny współczynnik, a następnie zsumowanie wyników składnik po składniku.
++
GameMaker używa funkcji gpu_set_blendmode() do zmiany sposobu mieszania, jakiego używa gra podczas rysowania. Możesz ją wywołać przed (na przykład) narysowaniem strony sprite, a następnie ustawić ją ponownie po zakończeniu rysowania, coś w tym stylu:
gpu_set_blendmode(bm_add);
draw_self();
gpu_set_blendmode(bm_normal);
That code draws the instance sprite using an additive blend mode. The additive blend mode is set using one of the available GML constants, of which there are four for basic modes:
+Ten kod rysuje instancję sprite przy użyciu addytywnego trybu mieszania. Tryb mieszania addytywnego jest ustawiany za pomocą jednej z dostępnych stałych GML, z których cztery są dostępne dla trybów podstawowych:
bm_normal
bm_add
bm_subtract
bm_max
We have seen already how bm_normal looks - since that's what everything defaults to! - so let's continue on to look at the other three in a bit more detail...
+Widzieliśmy już, jak wygląda strona bm_normal - ponieważ jest to domyślne ustawienie wszystkiego! - przyjrzyjmy się więc pozostałym trzem stronom nieco bardziej szczegółowo...
+
This blend mode adds the colours of the source and destination pixels together (but does not affect the alpha values). For example, if your background image is a solid colour with an RGB value of (100,15,70), and then you draw a rectangle with an RGB of (120,25,30), then (using bm_add) the fina RGB values for each pixel of the rectangle would be (220,40,100). Note that colour values can't go over 255 (or under 0), so anything that adds up to more than that will be clamped to 255.
-
Using this blend mode is a great way to get that "neon glow" look, and is most often used for lighting effects, or lasers or just about anything that you want to appear to glow or have luminescence.
+
Ten tryb mieszania sumuje kolory pikseli źródłowych i docelowych (ale nie ma wpływu na wartości alfa). Na przykład, jeśli obraz tła jest jednolitym kolorem o wartości RGB (100,15,70), a następnie narysujesz prostokąt o wartości RGB (120,25,30), to (używając bm_add) końcowe wartości RGB dla każdego piksela prostokąta będą wynosiły (220,40,100). Zauważ, że wartości kolorów nie mogą przekraczać 255 (lub być mniejsze od 0), więc wszystko, co daje więcej niż ta wartość, zostanie zaciśnięte na 255.
+Ten tryb mieszania to świetny sposób na uzyskanie efektu "neonowej poświaty". Najczęściej jest on używany do tworzenia efektów świetlnych, laserów i innych elementów, które mają sprawiać wrażenie świecących lub luminescencyjnych.
This blend mode is a bit different to the previous one, as it it works on a percentage basis rather than a direct value. This percentage is what will be subtracted from the destination colour (the colour of the pixel being drawn to). To explain this better, let's look at an example.
-
Imagine you want to reduce the red value of all pixels drawn in an area of the room by 25%. You would first need to get 25% of 255, then convert that into an RGB colour value, and then finally use that along with bm_subtract to draw over the area. Something like this:
Ten tryb mieszania różni się nieco od poprzedniego, ponieważ działa na zasadzie procentowej, a nie bezpośredniej wartości. Wartość procentowa jest tym, co zostanie odjęte od koloru docelowego (koloru piksela, do którego rysowany jest obraz). Aby lepiej to wyjaśnić, przyjrzyjmy się przykładowi.
+Wyobraź sobie, że chcesz zmniejszyć wartość koloru czerwonego wszystkich pikseli narysowanych w obszarze room o 25%. Musiałbyś najpierw uzyskać 25% z 255, następnie przekonwertować to na wartość koloru RGB, a na koniec użyć tego wraz z bm_subtract do narysowania obszaru. Coś w tym stylu:
var red = (25 / 100) * 255;
var col = make_colour_rgb(red, 0, 0);
gpu_set_blendmode(bm_subtract);
draw_rectangle_colour(0, 0, 128, 256, col, col, col, col, false);
gpu_set_blendmode(bm_normal);
Following the same rule, if you wanted to simply reduce the brightness of a background by 50% then you would have a colour that is 50% red, 50% green and 50% blue, ie: RGB (128, 128, 128). This blend mode is mainly used for drawing shadows, or creating interesting fade out effects.
-+
Zgodnie z tą samą zasadą, jeśli chcesz po prostu zmniejszyć jasność tła o 50%, uzyskasz kolor, który jest w 50% czerwony, w 50% zielony i w 50% niebieski, czyli RGB (128, 128, 128). Ten tryb mieszania jest używany głównie do rysowania cieni lub tworzenia ciekawych efektów wygaszania.
+
This blend mode is more complex to explain, but it basically multiplies the source colours by the source alpha, then adds them to the destination colour values multiplied by the inverse source colour values. The actual maths behind bm_max (and the other blend modes) we'll cover in part two of our article, but all you need to know is that the result will be a more "saturated" and brighter colour, without leading to the same pure white brilliance that using bm_add will cause.
-
This blend mode can be useful when you need to draw overlapping images without them becoming so bright that they can't be seen. The bright parts will become brighter, but they should still maintain a level of colour and hue. Note though that the alpha value of the source image will also influence in the final effect when using this blend mode.
Ten tryb mieszania jest bardziej skomplikowany do wyjaśnienia, ale w zasadzie mnoży on kolory źródłowe przez źródłową alfę, a następnie dodaje je do wartości kolorów docelowych pomnożonych przez odwrotność wartości kolorów źródłowych. Właściwą matematykę kryjącą się za bm_max (i innymi trybami mieszania) omówimy w drugiej części naszego artykułu, ale wystarczy wiedzieć, że rezultatem będzie bardziej "nasycony" i jaśniejszy kolor, nie prowadzący do tego samego czystego białego blasku, który spowoduje użycie bm_add.
+Ten tryb mieszania może być przydatny, gdy trzeba narysować nakładające się na siebie obrazy, a jednocześnie nie mogą one stać się tak jasne, że nie będzie ich widać. Jasne części staną się jaśniejsze, ale nadal powinny zachować odpowiedni poziom koloru i odcienia. Należy jednak pamiętać, że wartość alfa obrazu źródłowego również będzie miała wpływ na efekt końcowy przy użyciu tego trybu mieszania.
-
Now you know the very basics behind using a blend mode in GameMaker. It takes the RGB and alpha values for the source image (what is being drawn) and it then blends these with the RGB and alpha values of the destination (what is being drawn too). This blending is done by multiplying the individual components for each pixel colour and alpha by different amounts, depending on the effects that we wish to achieve. With this knowledge, you can start to use blend modes in your games to get glowing lasers, realistic shadows, or saturated transition effects, but there is still more to be learned here! Below we look at the extended blend modes, as well as explore a bit of the maths behind them, so that you can create your own blending effects like multiply or overlay.
--
Above we have talked about the function gpu_set_blendmode(), but now we are going to look at gpu_set_blendmode_ext(). This is (as the name implies) an extended function to set custom blend modes, but how does this work? Let's just have a look at the dry technical answer first before we go any further:
++
Teraz znasz już podstawy używania trybu mieszania w programie GameMaker. Tryb ten pobiera wartości RGB i alfa obrazu źródłowego (tego, co jest rysowane), a następnie miesza je z wartościami RGB i alfa obrazu docelowego (tego, co też jest rysowane). Mieszanie odbywa się poprzez mnożenie poszczególnych składowych dla każdego koloru piksela i alfa przez różne wartości, w zależności od efektów, jakie chcemy uzyskać. Mając tę wiedzę, możesz zacząć używać trybów mieszania w swoich grach, aby uzyskać świecące lasery, realistyczne cienie lub nasycone efekty przejścia, ale wciąż jest jeszcze wiele do nauczenia się! Poniżej przyjrzymy się rozszerzonym trybom mieszania, a także zgłębimy nieco matematyki, która się za nimi kryje, abyś mógł tworzyć własne efekty mieszania, takie jak mnożenie czy nakładanie.
++
Powyżej omówiliśmy funkcję gpu_set_blendmode()teraz zajmiemy się gpu_set_blendmode_ext(). Jest to (jak sama nazwa wskazuje) rozszerzona funkcja do ustawiania niestandardowych trybów mieszania, ale jak to działa? Zanim przejdziemy dalej, zapoznajmy się z suchą, techniczną odpowiedzią:
Now, while that text is correct and explains what blend modes do, it's not really intuitive... so let's go into a bit more detail and explain what this is all about.
-When we talk about the source we are talking about the colour and alpha values of the pixel that is being drawn, and when we talk about the destination we are talking about the colour and alpha values of the pixel that it is being drawn over. To keep things easier we can write out the source colour as it's components, like this:
+Chociaż tekst ten jest poprawny i wyjaśnia, na czym polegają tryby mieszania, nie jest zbyt intuicyjny... Dlatego też omówmy go nieco dokładniej i wyjaśnijmy, o co w tym wszystkim chodzi.
+Gdy mówimy o źródle , mamy na myśli kolor i wartości alfa rysowanego piksela, a gdy mówimy o miejscu docelowym , mamy na myśli kolor i wartości alfa piksela, nad którym jest ono rysowane. Aby ułatwić sobie pracę, możemy zapisać kolor źródłowy jako jego składowe, na przykład tak:
And the destination would be like this:
+A cel podróży wyglądałby tak:
So when we draw something on the screen, our graphics processor is actually doing the following for every single pixel:
+Kiedy więc rysujemy coś na ekranie, nasz procesor graficzny wykonuje następujące czynności dla każdego piksela:
final_pixel_colour = (Rs,Gs,Bs,As) * source_blend_factor + (Rd,Gd,Bd,Ad) * destination_blend_factor
-The blend factors mentioned above are defined in GameMaker by a number of GML constants, and each one represents a factor by which the source or destination R, G, B and A values should be multiplied by. The factors available are:
+Wspomniane wyżej współczynniki mieszania są zdefiniowane w programie GameMaker za pomocą kilku stałych GML, a każdy z nich reprezentuje współczynnik, przez który należy pomnożyć źródłowe lub docelowe wartości R, G, B i A. Dostępne są następujące współczynniki:
The four "basic" blend modes that GameMaker has are actually composites of two of these blend factors.
-Example of how bm_normal Works
+Cztery "podstawowe" tryby mieszania dostępne w programie GameMaker są w rzeczywistości kompozycjami dwóch z tych czynników mieszania.
+Time to look at a practical example of how this comes together for drawing in GameMaker. For this, we are going to look at bm_normal, which is really:
+Czas przyjrzeć się praktycznemu przykładowi, jak to się łączy w rysowaniu w GameMakerze. W tym celu przyjrzymy się bm_normal, który jest naprawdę:
gpu_set_blendmode_ext(bm_src_alpha, bm_inv_src_alpha);
-One of the problems people have with blend modes is visualising the results, so to show the maths behind them, we'll use this blend mode as our test subject since it's the blend mode that everyone uses the most and we know exactly what to expect from it. Imagine we are drawing a rectangle with the colour (128, 255, 64, 255) over a background with the colour (64, 128, 255, 255):
-
So, our blend mode looks like this:
Jednym z problemów, z jakimi borykają się użytkownicy trybów mieszania, jest wizualizacja wyników, dlatego aby pokazać, na czym polega matematyka, użyjemy tego trybu mieszania jako obiektu testowego, ponieważ jest on najczęściej używany przez wszystkich i wiemy dokładnie, czego można się po nim spodziewać. Wyobraźmy sobie, że rysujemy prostokąt o kolorze (128, 255, 64, 255) na tle o kolorze (64, 128, 255, 255):
+Tak więc nasz tryb mieszania wygląda następująco:
Source: (128, 255, 64, 255) = (0.5, 1, 0.25, 1)
Destination: (64, 128, 255, 255) = (0.25, 0.5, 1, 1)
bm_src_alpha (As, As, As, As) = (255, 255, 255, 255) = (1, 1, 1, 1)
@@ -104,7 +104,7 @@
As you can see, we multiply the destination values by 0, which gives them a value of 0 too, meaning that the source colours are unchanged, so our final colour value is (128, 255, 64, 255). You can see how the inclusion of alpha affects this value too:
+Jak widać, mnożymy wartości docelowe przez 0, co również daje im wartość 0, co oznacza, że kolory źródłowe pozostają niezmienione, a więc nasza ostateczna wartość koloru wynosi (128, 255, 64, 255). Widać, jak włączenie alfa wpływa również na tę wartość:
Source (128, 255, 64, 128) = (0.5, 1, 0.25, 0.5)
Destination: (64, 128, 255, 255) = (0.25, 0.5, 1, 1)
bm_src_alpha (As, As, As, As) = (128, 128, 128, 128) = (0.5, 0.5, 0.5, 0.5)
@@ -112,51 +112,51 @@
This gives a final pixel colour (96, 192, 159, 192), and will give an image like that shown below:
-
Hopefully you can see clearly now what the blend mode factors do, and how combining them can change what is drawn to create some interesting effects. We will now look at a practical example of how to combine these factors to create your own custom blend modes.
--
+
W ten sposób uzyskasz ostateczny kolor pikseli (96, 192, 159, 192), a w efekcie obraz podobny do pokazanego poniżej:
+
Mam nadzieję, że teraz wyraźnie widać, jak działają czynniki trybu mieszania i jak ich łączenie może zmienić rysowany obraz, tworząc interesujące efekty. Przyjrzymy się teraz praktycznemu przykładowi łączenia tych czynników w celu utworzenia własnych trybów mieszania.
++
Now you know how setting blend modes works and have seen an example of it being used for everyday drawing, let's look at something abit more complex...
--
Using the different factors available, you can create your own blend modes to achieve blending options that are not available to you normally. In this example, we are going to create a multiply effect like that used in Photoshop. We can simulate this blend mode using two of our above mentioned blend mode factor constants like this:
+Teraz, gdy już wiesz, jak działa ustawianie trybów mieszania i widziałeś przykład ich zastosowania w codziennym rysowaniu, przyjrzyjmy się czemuś bardziej złożonemu...
++
Korzystając z różnych dostępnych czynników, można tworzyć własne tryby mieszania, aby uzyskać opcje mieszania niedostępne w normalnych warunkach. W tym przykładzie zamierzamy utworzyć efekt mnożenia , taki jak w Photoshopie. Możemy zasymulować ten tryb mieszania, używając dwóch z wyżej wymienionych stałych współczynników trybu mieszania, jak poniżej:
gpu_set_blendmode_ext(bm_dest_colour, bm_zero);
-Before we actually draw something using this blend mode, let's have a look at how it should look in Photoshop:
-
Using our extended blend mode we get the following:
Zanim zaczniemy rysować coś przy użyciu tego trybu mieszania, zobaczmy, jak to powinno wyglądać w Photoshopie:
+Korzystając z rozszerzonego trybu mieszania, uzyskamy następujące wyniki:
(Rs, Gs, Bs, As) * (Rd, Gd, Bd, Ad) + (Rd, Gd, Bd, Ad) * (0,0,0,0) = (Rs, Gs, Bs, As) * (Rd, Gd, Bd, Ad)
Source colour * dest colour + dest colour * zero = source colour * dest colour
The blend factor bm_zero effectively removes the destination colour from the equation (as zero times anything is zero), so we are left with the source colour multiplied by the blend factor of the destination colour, hence the name "multiply" for the mode. To use this in GameMaker, you would simply have something like this in your Draw Event:
+Współczynnik mieszania bm_zero skutecznie usuwa kolor docelowy z równania (ponieważ zero razy cokolwiek jest zerem), więc pozostaje nam kolor źródłowy pomnożony przez współczynnik mieszania koloru docelowego, stąd nazwa trybu "multiply". Aby użyć tego trybu w programie GameMaker, wystarczy w zdarzeniu Draw wprowadzić coś takiego:
gpu_set_blendmode_ext(bm_dest_colour, bm_zero);
draw_self();
gpu_set_blendmode(bm_normal);
The next image was taken from a test project in GameMaker using this exact code:
-
Can you spot the difference? Probably not! There will, however, be some deviation between the two due to differences between the render tools used, but it's almost exactly as you would expect. Note though that not all the blend modes used by art programs are available to you within GameMaker due to the fact some of them can actually force the colour values to go over 255 and so create special effects, but that doesn't mean you can't create passable imitations of these effects, or even brand new effects, using them.
It's worth mentioning that with GameMaker you can take this one step further using the function gpu_set_blendmode_ext_sepalpha(). This permits you to separate out the alpha component of the different blend mode factors and use them individually to create even more possible combinations. We won't cover this function here as it's explained in depth already in the manual, but it's worth mentioning just so you know it's available for use.
--
One final thing is worth noting about blend modes, and that is how they affect the alpha component of a colour. When simply drawing to the application surface or the display buffer, you don't really need to take into consideration the destination alpha value as it will always be one. However surfaces that you make yourself are different, since you can clear a surface to have any alpha value from zero to one that you wish. This leads to some interesting effects that are contrary to what most people would expect.
-To illustrate this, we are going to look at drawing using the basic default bm_normal. Most people think that having a surface cleared to alpha 0, and then drawing something with an alpha of 0.5 will give a resulting alpha value 0.5 too... but this is not the case and is something that many people think is a "bug" in how GameMaker renders things. However, as you will see, it's not a bug at all!
-Say you have surface with every pixel at alpha 0, then you draw a circle on it with alpha 0.5 using the bm_normal blend mode. The entire surface is still going to be alpha 0, but in the circle the alpha will actually be 0.25, since:
+Następny obraz pochodzi z projektu testowego w witrynie GameMaker, w którym użyto dokładnie tego kodu:
+Czy potrafisz dostrzec różnicę? Prawdopodobnie nie! Będą jednak występować pewne odchylenia między nimi ze względu na różnice między używanymi narzędziami do renderowania, ale jest to prawie dokładnie tak, jak można by się spodziewać. Należy jednak pamiętać, że nie wszystkie tryby mieszania używane w programach artystycznych są dostępne w GameMakerze, ponieważ niektóre z nich mogą wymuszać przekroczenie wartości 255 i w ten sposób tworzyć efekty specjalne, ale nie oznacza to, że nie można za ich pomocą tworzyć udanych imitacji tych efektów, a nawet zupełnie nowych efektów.
Warto wspomnieć, że w GameMakerze można pójść o krok dalej, korzystając z funkcji gpu_set_blendmode_ext_sepalpha(). Pozwala ona wyodrębnić składowe alfa różnych trybów mieszania i używać ich pojedynczo w celu tworzenia jeszcze większej liczby możliwych kombinacji. Nie będziemy tutaj omawiać tej funkcji, ponieważ jest ona szczegółowo opisana w podręczniku, ale warto o niej wspomnieć, abyś wiedział, że można z niej korzystać.
++
Warto jeszcze zwrócić uwagę na jedną rzecz związaną z trybami mieszania, a mianowicie na to, jak wpływają one na składową alfa koloru. Podczas rysowania na powierzchni aplikacji lub w buforze monitora nie trzeba brać pod uwagę docelowej wartości alfa, ponieważ zawsze będzie ona równa jeden. W przypadku powierzchni, które tworzysz samodzielnie, jest inaczej, ponieważ możesz nadać im dowolną wartość alfa w zakresie od zera do jednego. Prowadzi to do ciekawych efektów, które są sprzeczne z oczekiwaniami większości ludzi.
+Aby to zilustrować, przyjrzymy się rysowaniu przy użyciu podstawowej, domyślnej opcji bm_normal. Większość ludzi myśli, że jeśli powierzchnia jest wyczyszczona do wartości alfa 0, a następnie narysuje coś z alfą 0,5, to wynikowa wartość alfa też wyniesie 0,5... ale tak nie jest i wiele osób uważa to za "błąd" w sposobie renderowania w GameMakerze. Jednak, jak się przekonasz, to wcale nie jest błąd!
+Powiedzmy, że mamy powierzchnię, której każdy piksel ma alfę 0, a następnie rysujemy na niej okrąg z alfą 0,5 za pomocą trybu mieszania bm_normal. Cała powierzchnia nadal będzie miała alfa 0, ale w okręgu alfa będzie wynosić 0,25, ponieważ:
0.5 * 0.5 + 0 * 0.5 = 0.5 * 0.5 = 0.25
-If you then proceed to draw another circle in the existing circle, also with an alpha of 0.5, then the alpha outside the circles would be 0, in between the circles 0.25, and in the smaller circle it would be 0.375:
+Jeśli następnie narysujesz kolejny okrąg w istniejącym okręgu, również z alfą 0,5, to alfa poza okręgiem wyniesie 0, między okręgami 0,25, a w mniejszym okręgu 0,375:
0.5 * 0.5 + 0.25 * 0.5 = 0.25 + 0.125 = 0.375
-If you were to continue to draw a number of 0.5 alpha circles to a surface with 0 alpha, and then draw this surface to the room, you would be able to clearly see this:
-
If you are still a bit confused about the alpha, try to picture it as just another colour. It behaves like a colour and all calculations on it are done in a similar manner. It's just not really visible, although the effect it has on other colours is. Which brings us to the final thing to note when using surfaces and blend modes (even bm_normal)...
Even if the alpha of the surface is 0, the colour components are still there and exist and will influence in all blending operations. So drawing to a zero alpha cleared surface that has been cleared using the colour red (for example) will blend the source colours with the destination colours and give different effects to that which you may think. The above image was created on a surface cleared to black over a black background, but if we clear the surface to red, we get this instead:
-
Hopefully you can now work out why this happens for yourself using the formulas I've outlined above and applying the appropriate figures for bm_normal.
-
-
+
Jeśli nadal będziesz rysować pewną liczbę okręgów o alfie 0,5 na powierzchni o alfie 0, a następnie narysujesz tę powierzchnię na stronie room, będziesz mógł to wyraźnie zobaczyć:
+Jeśli nadal nie wiesz, czym jest alfa, spróbuj wyobrazić ją sobie jako kolejny kolor. Zachowuje się jak kolor i wszystkie obliczenia na nim są wykonywane w podobny sposób. Po prostu nie jest widoczna, choć wpływ, jaki wywiera na inne kolory, jest widoczny. W ten sposób dochodzimy do ostatniej rzeczy, na którą należy zwrócić uwagę podczas używania powierzchni i trybów mieszania (nawet na stronie bm_normal)...
Nawet jeśli alfa powierzchni jest równa 0, składowe koloru nadal tam są, istnieją i będą miały wpływ na wszystkie operacje mieszania. Zatem rysowanie na powierzchni o zerowej alfie, która została oczyszczona przy użyciu koloru czerwonego (na przykład), spowoduje mieszanie kolorów źródłowych z docelowymi i da inne efekty niż się wydaje. Powyższy obrazek został utworzony na czarnej powierzchni na czarnym tle, ale jeśli wyczyścimy powierzchnię na czerwono, otrzymamy taki efekt:
+Mam nadzieję, że teraz można samemu ustalić, dlaczego tak się dzieje, korzystając ze wzorów, które przedstawiłem powyżej, i stosując odpowiednie liczby dla strony bm_normal.
+
+
-
A buffer (in programming) is basically a space within the system memory that is used to store small packets of data for just about anything (for example: data transfer, collisions, colour data, etc.). Since it is held in system memory it is very fast to access, and a buffer would generally be used for very short-term storage, like receiving network information before processing it, or for storing a checkpoint in your game (this is explained in the example given further down the page).
-
Buffers are created by allocating a space in the system memory, calculated in byte s, which is then reserved for your game as long as your game is running or until you delete the buffer using the appropriate function (you can find all the GML buffer functions listed here). This means that even when your game is not in focus (for example, on a mobile device when you take a call the game will be put into the background) the buffer will still exist, however if the game is closed or re-started the buffer will be lost.
Restarting the game will not clear or delete the buffer! But it will prevent any further access to the previously created buffer as the ID handle will have been lost, causing a memory leak which will crash your game eventually. So, when re-starting a game, remember to delete any buffers first.
-GameMaker permits the creation of four different buffer types. The reason for this is that buffers are designed to be a highly optimised temporary storage medium, and as such you should create a buffer that is appropriate to the type of data that you wish it to store, otherwise you could get errors or cause a bottleneck in your code. Before explaining this further, let's look at the four available buffer types (defined as constants in GML):
-+
Strona buffer (w programowaniu) to miejsce w pamięci systemowej, które służy do przechowywania małych pakietów danych dotyczących praktycznie wszystkiego (np. transferu danych, kolizji, kolorów itp.). Ponieważ jest przechowywana w pamięci systemowej, dostęp do niej jest bardzo szybki, a buffer jest zwykle używana do bardzo krótkotrwałego przechowywania danych, na przykład do odbierania informacji z sieci przed ich przetworzeniem lub do przechowywania punktu kontrolnego w grze (wyjaśniono to w przykładzie podanym w dalszej części strony).
+Bufory są tworzone poprzez przydzielenie miejsca w pamięci systemowej , liczonego w bajtach, które jest następnie rezerwowane dla Twojej gry tak długo, jak gra jest uruchomiona, lub do momentu usunięcia buffer za pomocą odpowiedniej funkcji (wszystkie funkcje GML buffer znajdziesz tutaj). Oznacza to, że nawet jeśli gra nie jest w centrum uwagi (np. na urządzeniu przenośnym, gdy odbierasz połączenie, gra przechodzi w tło), adres buffer będzie nadal istniał, jednak w przypadku zamknięcia lub ponownego uruchomienia gry adres buffer zostanie utracony.
UWAGA: Ponowne uruchomienie gry nie spowoduje wyczyszczenia ani usunięcia adresu buffer! Uniemożliwi jednak dalszy dostęp do wcześniej utworzonej strony buffer, ponieważ utracony zostanie uchwyt identyfikacyjny, co spowoduje wyciek pamięci, który w końcu doprowadzi do awarii gry. Dlatego przy ponownym uruchamianiu gry pamiętaj, aby najpierw usunąć wszystkie buffers.
+GameMaker pozwala na tworzenie czterech różnych typów buffer. Powodem tego jest fakt, że buffers został zaprojektowany jako wysoce zoptymalizowany tymczasowy nośnik danych i dlatego powinieneś utworzyć buffer odpowiedni do typu danych, które chcesz w nim przechowywać, w przeciwnym razie możesz otrzymać błędy lub spowodować wąskie gardło w swoim kodzie. Zanim wyjaśnimy to dalej, przyjrzyjmy się czterem dostępnym typom buffer (zdefiniowanym jako stałe w GML):
+
| Constant | -description | +Stała | +opis |
|---|---|---|---|
| buffer_fixed | -- A buffer of a fixed size in bytes. The size is set when the buffer is created and cannot be changed again. |
+ buffer_fixed | ++ Adres buffer o stałym rozmiarze w bajtach. Rozmiar jest ustalany podczas tworzenia strony buffer i nie może być ponownie zmieniony. |
| buffer_grow | -- A buffer that will grow dynamically as data is added. You create it with an initial size (which should be an approximation of the size of the data expected to be stored), and then it will expand to accept further data that overflows this initial size. |
+ buffer_grow | ++ Strona buffer, która będzie się dynamicznie powiększać w miarę dodawania danych. Tworzy się ją z rozmiarem początkowym (który powinien być przybliżony do rozmiaru danych, które mają być przechowywane), a następnie rozszerza się ją, aby przyjąć dalsze dane, które przekraczają ten rozmiar początkowy. |
| buffer_wrap | -- A buffer where the data will wrap. When the data being added reaches the limit of the buffer size, the overwrite will be placed back at the start of the buffer, and further writing will continue from that point. |
+ buffer_wrap | ++ Adres buffer, na który będą zawijane dane. Gdy dodawane dane osiągną limit rozmiaru buffer, nadpisanie zostanie umieszczone z powrotem na początku buffer, a dalszy zapis będzie kontynuowany od tego miejsca. |
| buffer_fast | -- This is a special "stripped down" buffer that is extremely fast to read/write to. However it can only be used with buffer_u8 data types, and must be 1 byte aligned. (Information on data types and byte alignment can be found further down this page). |
+ buffer_fast | ++ Jest to specjalny, "okrojony" adres buffer, na którym można bardzo szybko odczytywać i zapisywać dane. Można go jednak używać tylko z typami danych buffer_u8 i musi być wyrównany do 1 bajta. (Informacje o typach danych i wyrównywaniu bajtów można znaleźć w dalszej części tej strony). |
-
Those are the buffer types available to you when using GameMaker, and which one you choose will greatly depend on the use you wish to put it to. For example, a grow buffer would be used for storing a "snapshot" of data to create a save game since you do not know the actual amount of data that is going to be placed in it, or a fast buffer would be used when you know that the values you are working with are all between 0 and 255 or -128 and 127, for example when processing ARGB data from an image.
-
When creating a buffer, you should always try to create it to a size that is appropriate to the type, with the general rule being that it should be created to accommodate the maximum size of data that it is to store, and if in doubt, use a grow buffer to prevent overwrite errors.
The actual code to create a buffer would look something like this:
++
Są to typy buffer dostępne w programie GameMaker, a to, który z nich wybierzesz, zależy w dużej mierze od tego, do czego chcesz go wykorzystać. Na przykład strona grow buffer byłaby używana do przechowywania "migawek" danych w celu utworzenia zapisu gry, ponieważ nie znasz rzeczywistej ilości danych, które zostaną w niej umieszczone, lub szybka buffer byłaby używana, gdy wiesz, że wszystkie wartości, z którymi pracujesz, zawierają się w przedziale od 0 do 255 lub od -128 do 127, na przykład podczas przetwarzania danych ARGB z obrazu.
+Tworząc stronę buffer, należy zawsze starać się nadać jej rozmiar odpowiedni dla danego typu, przy czym ogólna zasada mówi, że powinna ona być utworzona tak, aby pomieścić maksymalny rozmiar danych, które ma przechowywać, a w razie wątpliwości należy użyć grow buffer, aby zapobiec błędom nadpisywania.
Faktyczny kod tworzący stronę buffer wygląda mniej więcej tak:
player_buffer = buffer_create(16384, buffer_fixed, 2);
-
- That would create a fixed buffer of 16384 bytes and byte-aligned to 2, with the function returning a unique ID value that is stored in a variable for later referencing of this buffer.
When reading and writing data to a buffer, you do it in "chunks" of data defined by their "data type". The "data type" sets the number of bytes allocated within the buffer for the value being written, and it is essential that you get this correct otherwise you will get some very strange results (or even errors) for your code.
-Buffers are written to (and read from) sequentially, in that one piece of data is written after another, with each piece of data being of a set type. This means that you should ideally be aware of what data you are writing to the buffer at all times. These data types are defined in GML by the following constants:
-So, say you have created a buffer and you want to write information to it, then you would use something like the following code:
+
+ W ten sposób powstałaby stała strona buffer o rozmiarze 16384 bajtów i wyrównana do 2 bajtów. Funkcja zwróciłaby unikatową wartość identyfikacyjną, która jest przechowywana w zmiennej w celu późniejszego odwoływania się do tej strony buffer.
Podczas odczytywania i zapisywania danych na stronie buffer robi się to w "kawałkach" danych określonych przez ich "typ danych". Typ danych" określa liczbę bajtów przydzielonych w ramach buffer dla zapisywanej wartości i bardzo ważne jest, aby go poprawnie określić, w przeciwnym razie można uzyskać bardzo dziwne wyniki (lub nawet błędy) w swoim kodzie.
+Bufory są zapisywane (i odczytywane) sekwencyjnie, tzn. jedna porcja danych jest zapisywana po drugiej, a każda porcja danych jest określonego typu. Oznacza to, że użytkownik powinien zawsze wiedzieć, jakie dane zapisuje w buforze buffer. Te typy danych są zdefiniowane w witrynie GML za pomocą następujących stałych:
++
| Typ danych Stała | +Bajty | +Opis | +
|---|---|---|
| buffer_u8 | +1 | ++ 8-bitowa liczba całkowita bez znaku. Jest to wartość dodatnia z zakresu od 0 do 255. |
+
| buffer_s8 | +1 | ++ Podpisana, 8-bitowa liczba całkowita. Może to być wartość dodatnia lub ujemna z zakresu od -128 do 127 (0 jest wartością dodatnią). |
+
| buffer_u16 | +2 | ++ Niepodpisana, 16-bitowa liczba całkowita. Jest to wartość dodatnia z zakresu od 0 do 65 535. |
+
| buffer_s16 | +2 | ++ Podpisana, 16-bitowa liczba całkowita. Może to być wartość dodatnia lub ujemna z zakresu od -32,768 do 32,767 (0 oznacza wartość dodatnią). |
+
| buffer_f16 | +2 | ++ 16-bitowa liczba zmiennoprzecinkowa. Może to być wartość dodatnia lub ujemna z zakresu +/- 65504. (Obecnie nieobsługiwana!) |
+
| buffer_u32 | +4 | ++ Niepodpisana, 32-bitowa liczba całkowita. Jest to wartość dodatnia z zakresu od 0 do 4 294 967 295. |
+
| buffer_s32 | +4 | ++ Podpisana, 32-bitowa liczba całkowita. Może to być wartość dodatnia lub ujemna z zakresu od -2,147,483,648 do 2,147,483,647 (0 oznacza wartość dodatnią). |
+
| buffer_f32 | +4 | ++ 32-bitowa liczba zmiennoprzecinkowa. Może to być wartość dodatnia lub ujemna z zakresu +/-16777216. |
+
| buffer_u64 | +8 | ++ 64-bitowa liczba całkowita bez znaku.(Obecnie nie jest obsługiwana przez wszystkie funkcje buffer!) |
+
| buffer_f64 | +8 | ++ 64-bitowa liczba zmiennoprzecinkowa. |
+
| buffer_bool | +1 | ++ Wartość logiczna. Może wynosić tylko 1 lub 0 (true lub false). |
+
| buffer_string | +N/A | ++ Jest to plik UTF-8 zakończony zerem (0x00) string. Zasadniczo adres GameMaker string jest umieszczany w adresie buffer, a na końcu jest umieszczane 0. |
+
+
Jeśli więc utworzyłeś stronę buffer i chcesz zapisywać na niej informacje, użyj następującego kodu:
buffer_write(buff, buffer_bool, global.Sound);
buffer_write(buff, buffer_bool, global.Music);
buffer_write(buff, buffer_s16, obj_Player.x);
buffer_write(buff, buffer_s16, obj_Player.y);
buffer_write(buff, buffer_string, global.Player_Name);
looking at the example above you can see that you can write different types of data to a buffer at the same time (you are only limited to a specific data type when using the fast buffer type), and this data will be added into the buffer sequentially (although its actual position in the buffer will depend on its byte-alignment, explained below). This is the same for reading information from the buffer too, and in the case of the example given above, you would read from the buffer in the same order that you wrote the data, checking for the same data type, eg:
+Patrząc na powyższy przykład, widać, że można zapisywać różne typy danych na stronie buffer w tym samym czasie (w przypadku korzystania z szybkiego bufora jesteśmy ograniczeni tylko do jednego typu danych), a dane te będą kolejno dodawane do strony buffer (choć ich faktyczna pozycja w buffer będzie zależała od wyrównania bajtów, co wyjaśniono poniżej). Tak samo jest w przypadku odczytywania informacji z buffer. W powyższym przykładzie dane z buffer należy odczytywać w takiej samej kolejności, w jakiej zostały zapisane, sprawdzając, czy dane są tego samego typu, np:
global.Sound = buffer_read(buff, buffer_bool);
global.Music = buffer_read(buff, buffer_bool);
obj_Player.x = buffer_read(buff, buffer_s16);
obj_Player.y = buffer_read(buff, buffer_s16);
global.Player_Name = buffer_read(buff, buffer_string);
As you can see, you read out information in the same order that you read it into the buffer. For further information on how to add and remove data from the buffer please see the examples given below.
-If you have been reading through this page you will have seen references to the byte-alignment of a buffer. This basically refers to the position that new data will stored at within a given buffer. How does this work? Well, for a single byte aligned buffer, each piece of data is written to the buffer sequentially, with each new data piece being added directly after the previous. However a 2 byte aligned buffer will write each piece of data to intervals of 2 bytes, so that even if your initial write is 1 byte of data, the next write will be moved to align to two bytes:
-
So, if your byte-alignment is set to, say, 4 bytes and you write a single piece of data which is 1 byte in size then do a buffer tell (a tell gets the current position for reading/writing for the buffer), you'll get an offset of 1 byte (the offset in this case is the number of bytes from the start of the buffer to the current read/write position).
However, if you write another piece of data, also 1 byte in size, then do a buffer tell, you'll get an offset of 5 bytes (even though you have only written 2 bytes of data) as the alignment has padded the data to align it with the 4 byte buffer alignment.
-Basically, what this means is that alignment will only affect where things are written to, so if you do a buffer tell after you write something, it'll return the current write position which immediately follows the data you've previously written. Note, however, that if you then write another piece of data, internally the buffer will move the write position along to the next multiple of the alignment size before actually writing the piece of data.
-Below we have a couple of examples of how to use buffers in a project:
- +Jak widać, informacje są odczytywane w takiej samej kolejności, w jakiej zostały wczytane do buffer. Więcej informacji na temat dodawania i usuwania danych z buffer można znaleźć w poniższych przykładach.
+Jeśli czytałeś tę stronę, na pewno widziałeś wzmianki o wyrównaniu bajtów w adresie buffer. Odnosi się to do pozycji, na której nowe dane będą zapisywane w danym adresie buffer. Jak to działa? Otóż w przypadku strony buffer z wyrównaniem do jednego bajtu każda porcja danych jest zapisywana na stronie buffer kolejno, przy czym każda nowa porcja danych jest dodawana bezpośrednio po poprzedniej. Natomiast w przypadku strony buffer z wyrównaniem do 2 bajtów każdy fragment danych będzie zapisywany w odstępach 2-bajtowych, więc nawet jeśli początkowy zapis wyniesie 1 bajt danych, następny zapis zostanie wyrównany do dwóch bajtów:
+Jeśli więc wyrównanie bajtowe jest ustawione na, powiedzmy, 4 bajty i zapiszesz pojedynczy fragment danych o rozmiarze 1 bajta, a następnie wykonasz tell buffer (tell określa bieżącą pozycję do odczytu/zapisu dla buffer), otrzymasz przesunięcie o 1 bajt (przesunięcie w tym przypadku to liczba bajtów od początku adresu buffer do bieżącej pozycji odczytu/zapisu).
Jeśli jednak zapiszesz kolejną porcję danych, również o rozmiarze 1 bajta, a następnie wykonasz buffer tell, otrzymasz przesunięcie o 5 bajtów (mimo że zapisałeś tylko 2 bajty danych), ponieważ wyrównanie spowodowało wyścielenie danych, aby wyrównać je do 4-bajtowego wyrównania buffer.
+Zasadniczo oznacza to, że wyrównanie będzie miało wpływ tylko na miejsce zapisu, więc jeśli wykonasz buffer tell po zapisaniu czegoś, zwróci ono bieżącą pozycję zapisu, która znajduje się bezpośrednio za wcześniej zapisanymi danymi. Zauważ jednak, że jeśli następnie napiszesz kolejną porcję danych, to buffer wewnętrznie przesunie pozycję zapisu do następnej wielokrotności rozmiaru wyrównania przed faktycznym zapisem porcji danych.
+Poniżej przedstawiamy kilka przykładów wykorzystania strony buffers w projekcie:
++
A simple example of how a buffer can be used in any GameMaker game for any platform, is the function game_save_buffer(). This function will take a "snapshot" of the current game state and save it to a pre-defined buffer, which can then be read from to load the game at that point again.
-This function is very limited and it is designed for the beginner to get a checkpoint system up and running quickly, but more advanced users may prefer to code their own system using the File functions, due to the fact that the game will not save any of the dynamic resources that you can create at run-time like data structures, surfaces, added sprites, etc...
-The first thing we need to do is create a new object to control the saving and loading, so you would make one and give it a Create Event. In this event, you could place the following code:
+Prostym przykładem na to, jak można wykorzystać stronę buffer w dowolnej grze GameMaker na dowolną platformę, jest funkcja game_save_buffer(). Funkcja ta wykonuje "migawkę" bieżącego stanu gry i zapisuje ją w zdefiniowanym wcześniej adresie buffer, który można następnie odczytać, aby ponownie załadować grę w tym samym punkcie.
+UWAGA: Ta funkcja jest bardzo ograniczona i została zaprojektowana dla początkujących graczy, aby szybko uruchomić system punktów kontrolnych. Bardziej zaawansowani użytkownicy mogą jednak preferować kodowanie własnego systemu przy użyciu funkcji pliku, ponieważ gra nie zapisze żadnych zasobów dynamicznych, które można utworzyć w czasie gry, takich jak struktury danych, powierzchnie, dodane strony sprites, itp.
+Pierwszą rzeczą, którą musimy zrobić, jest utworzenie nowego adresu object, który będzie sterował zapisywaniem i ładowaniem danych, dlatego należy go utworzyć i nadać mu zdarzenie Create. W tym zdarzeniu można umieścić następujący kod:
SaveBuffer = buffer_create(1024, buffer_grow, 1);
StateSaved = false;
The first line creates a grow buffer (since we don't know the final size of the saved data) of 1024 bytes and aligned to 1 byte. A variable is then created to check against and see if the game has been saved or not (this will be used for loading).
-Next we would add a Keypress Event (for example) in which we will save the current game state to the created buffer:
+W pierwszym wierszu tworzony jest plik grow buffer (ponieważ nie znamy ostatecznego rozmiaru zapisanych danych) o rozmiarze 1024 bajtów i wyrównany do 1 bajta. Następnie tworzona jest zmienna, która będzie sprawdzać, czy gra została zapisana, czy nie (zostanie ona użyta podczas wczytywania).
+Następnie dodajemy zdarzenie naciśnięcia klawisza (na przykład), w którym zapiszemy bieżący stan gry do utworzonego bufora:
StateSaved = true;
buffer_seek(SaveBuffer, buffer_seek_start, 0);
game_save_buffer(SaveBuffer);
The above will first set the control variable to true (so that this is saved when we save the game to the buffer) and then seek to the start of the buffer before writing the current save state into it. Why do we use buffer_seek()? Well, as mentioned already on this page, you read and write to a buffer from the last position that data was added to it. This means that if you don't set the buffer tell back to the start then when you save you will be adding the data into the buffer at the current buffer read/write position. So, we use the function buffer_seek() to move the tell to the buffer start.
-We have now saved the current game state to a buffer. The next step would be to code how to load it, probably in another Keypress Event:
+Powyższe działanie spowoduje najpierw ustawienie zmiennej sterującej na true (dzięki czemu zostanie ona zapisana podczas zapisywania gry na stronie buffer), a następnie przejście na początek strony buffer przed zapisaniem do niej bieżącego stanu zapisu. Dlaczego używamy buffer_seek()? Otóż, jak już wspomniano na tej stronie, czytasz i zapisujesz na stronie buffer od miejsca, w którym ostatnio zostały do niej dodane dane. Oznacza to, że jeśli nie ustawisz buffer tell z powrotem na początek, to podczas zapisywania dane zostaną dodane do buffer w bieżącej pozycji odczytu/zapisu buffer. Dlatego użyjemy funkcji buffer_seek(), aby przenieść tell na początek buffer.
+Aktualny stan gry został zapisany na stronie buffer. Następnym krokiem będzie zakodowanie sposobu jego załadowania, prawdopodobnie w innym zdarzeniu Keypress Event:
if StateSaved
{
buffer_seek(SaveBuffer, buffer_seek_start, 0);
game_load_buffer(SaveBuffer);
}
The game will then be loaded at the end of the event in which you place the above code.
-This is only for use in the same room, and not for generating complete saved games for after your game has been closed or restarted!
-The final thing to add to the controller object is some "clean up" code. Buffers are stored in memory and as such if you do not clean up when you are finished with them, you can get memory leaks that will eventually lag and crash your game. So you would probably add a Room End Event (from the Other event category) with:
+Gra zostanie załadowana na końcu zdarzenia, w którym umieszczono powyższy kod.
+UWAGA: Można tego używać tylko w tej samej witrynie room, a nie do generowania kompletnych zapisanych gier po zamknięciu lub ponownym uruchomieniu gry!
+Ostatnią rzeczą, którą należy dodać do kontrolera object, jest kod "czyszczący". Buffers są przechowywane w pamięci i jeśli nie wyczyścisz ich po zakończeniu, mogą wystąpić wycieki pamięci, które w końcu spowodują lagi i awarię gry. Można więc dodać zdarzenie zakończenia pomieszczenia (z kategorii Inne zdarzenia ) o treści:
buffer_delete(SaveBuffer);
-This object can now be placed into a room and on a key press save and load the room state from a buffer.
-+
Tę stronę object można teraz umieścić w witrynie room, a po naciśnięciu klawisza zapisać i załadować stan room z witryny buffer.
+
When working with the GameMaker networking functions, you have to use buffers to create the data packet that is being sent over the network connection. This example intends to show how this is done, but due to the scope of the networking possibilities, it is only designed to show how to use the buffers themselves, and not the full networking system.
-The first thing we will show is the creation and use of a buffer for the client side of the network connection. This buffer will be used to create small data packets that can then be sent to the server, so in the Create Event of an instance we would assign a buffer like this:
+Podczas pracy z funkcjami sieciowymi programu GameMaker należy używać adresu buffers do tworzenia pakietów danych, które są przesyłane przez połączenie sieciowe. Ten przykład ma na celu pokazanie, jak to się robi, ale ze względu na zakres możliwości sieciowych ma on na celu jedynie pokazanie, jak używać samego buffers, a nie całego systemu sieciowego.
+Pierwszą rzeczą, którą pokażemy, jest tworzenie i używanie buffer po stronie klienta połączenia sieciowego. Ta strona buffer będzie używana do tworzenia małych pakietów danych, które następnie będą mogły być wysyłane do strony server, dlatego w zdarzeniu tworzenia instancji przypisalibyśmy jej adres buffer w następujący sposób:
send_buff = buffer_create(256, buffer_grow, 1);
-We make the buffer small (256 bytes) - as it is not intended for holding large amounts of data - then we make it a grow buffer to ensure no errors should we need to add more data to be sent at any time, and the alignment is set to one for convenience.
-Now, let's say that we want our client to send data to the server. For that we need to create a buffer "packet", and in this example we are going to send a Key Press Event, like when the player presses Left Arrow to move around the game. To do this we write the necessary data to the buffer first then send it off:
+Strona buffer jest niewielka (256 bajtów), ponieważ nie jest przeznaczona do przechowywania dużych ilości danych, a następnie jest powiększana (grow buffer ), aby zapewnić brak błędów w przypadku konieczności dodania większej ilości danych do wysłania w dowolnym momencie, a wyrównanie jest ustawione na jeden dla wygody.
+Załóżmy, że chcemy, aby nasz klient wysyłał dane do server. W tym celu musimy utworzyć "pakiet" buffer. W tym przykładzie wyślemy zdarzenie naciśnięcia klawisza, np. gdy gracz naciśnie strzałkę w lewo , aby poruszać się w grze. Aby to zrobić, najpierw zapisujemy niezbędne dane na stronie buffer, a następnie je wysyłamy:
buffer_seek(buff, buffer_seek_start, 0);
buffer_write(buff, buffer_u8, 1);
buffer_write(buff, buffer_s16, vk_left);
buffer_write(buff, buffer_bool, true);
network_send_packet(client, buff, buffer_tell(buff));
Before writing to the buffer we have set the "tell" to the start of the buffer as networking always takes the data from the start of a buffer. We then write the check value (this will be used by the server to determine the type of event to be processed), then the key being used, and then the state of the key (in this case true for pressed). This buffer is then sent as a data packet by the network function. Note that we do not send the whole buffer! We only send the data written, using the buffer_tell function to return the current read/write position of the buffer (remember that writing to the buffer moves the "tell" to the end of what has been written). This is simply to avoid sending more bytes than is necessary.
-What about receiving the data on the server? The received data packet that must be written into the buffer on the server and then used to update the game. For that we would use the Networking Asynchronous Event in the network controller object of the server, as this simplified code below shows:
+Przed zapisem na stronie buffer ustawiamy "tell" na początek strony buffer, ponieważ sieci zawsze pobierają dane od początku strony buffer. Następnie wpisujemy wartość kontrolną (zostanie ona wykorzystana przez stronę server do określenia typu zdarzenia, które ma zostać przetworzone), używany klawisz, a następnie stan klawisza (w tym przypadku true oznacza naciśnięty). Ta strona buffer jest następnie wysyłana przez funkcję sieciową jako pakiet danych. Zwróć uwagę, że nie wysyłamy całej strony buffer! Wysyłamy tylko zapisane dane, używając funkcji buffer_tell do zwrócenia aktualnej pozycji odczytu/zapisu na stronie buffer (pamiętaj, że zapis na stronie buffer przenosi "tell" na koniec tego, co zostało zapisane). Ma to na celu uniknięcie wysyłania większej liczby bajtów, niż jest to konieczne.
+A co z odbiorem danych na stronie server? Odebrany pakiet danych musi zostać zapisany w buffer na stronie server, a następnie wykorzystany do aktualizacji gry. W tym celu należy użyć zdarzenia asynchronicznego Networking w kontrolerze sieciowym object na stronie server, jak pokazano w poniższym uproszczonym kodzie:
var buff = ds_map_find_value(async_load, "buffer");
if cmd == buffer_read(buff, buffer_u8);
{
key = buffer_read(buff, buffer_s16);
key_state = buffer_read(buff, buffer_bool);
}
The asynchronous event will contain a special temporary DS map async_load (it is removed from memory at the end of the event automatically) which contains different information depending on the type of incoming data from the network. In this case, we are assuming that the map has been checked and found to be a buffer data packet sent from a client. We now check the first piece of data that is in the buffer to see what kind of event has been sent - in this case the value "1" represents a key event, however when coding these things you should define constants to hold these values to simplify things - and then store the key being pressed and its state (true = pressed, false = released). This information would then be used to update all the clients with the new status of the sending client player.
-The buffer that is created from the DS map is automatically removed at the end of the Network Asynchronous Event so there is no need to use buffer_delete() here.
-+
Zdarzenie asynchroniczne będzie zawierało specjalną tymczasową mapę DS async_load (jest ona usuwana z pamięci po zakończeniu zdarzenia automatycznie), która zawiera różne informacje w zależności od typu danych przychodzących z sieci. W tym przypadku zakładamy, że mapa została sprawdzona i uznana za pakiet danych buffer wysłany od klienta. Sprawdzamy teraz pierwszą część danych, która znajduje się na stronie buffer, aby sprawdzić, jakiego rodzaju zdarzenie zostało wysłane - w tym przypadku wartość "1" oznacza zdarzenie związane z klawiszem, jednak podczas kodowania takich rzeczy należy zdefiniować stałe przechowujące te wartości, aby uprościć pracę - a następnie zapisujemy naciśnięty klawisz i jego stan (true = naciśnięty, false = zwolniony). Te informacje zostaną następnie użyte do zaktualizowania wszystkich klientów o nowy stan gracza wysyłającego.
+UWAGA: Strona buffer utworzona z mapy DS jest automatycznie usuwana na końcu zdarzenia asynchronicznego sieci, więc nie ma potrzeby używania tutaj funkcji buffer_delete().
+
-
-
+
+
+
-
This guide is for those of you who want to understand how to use and create particles in GML. This page will cover both the GML Code functions and GML Visual actions for particles, so if you've never used particles before, we hope that this guide can get you started as they are very useful and quite fun to make.
-Before going any further, we should probably explain what a particle actually is... Basically, a particle is a graphic resource that has certain properties which are defined by a particle system. These properties cannot be manipulated directly for individual particles, but are changed collectively through the code or actions that are used to define the system that it belongs to. They are very useful for creating beautiful and flashy effects - or subtle and discreet ones - in a game without the CPU overhead that using instances has.
-We have mentioned particle systems, so let's explain what that is before continuing. Think of a particle system like a container that you will use to hold your particles ready for use. You can use code or actions to define the visual aspect of the particles, and then they are placed in the "container" (the particle system) so that you can take it out and use it whenever and wherever you need it later.
-Before setting up a system and creating particles, it's important to know a few things... First is that most of a particle systems code is only ever called once in the game, usually in some type of controller object in the first room or level - this is not always the case, but for the sake of simplicity, we'll be using this scenario for the following brief guide as it's the most common way to use particles. You do this because a particle system, once created, stays in memory and is ready to be used at any time, so if you create it more than once it can quickly increase the memory usage and cause serious lag, and even has the potential of crashing the game. For the sake of simplicity in this guide, you will make a global particle system that can be used by any instance in the game at any time.
-- -
To start with you need to define the particle system and give it a name so that you can use it. As this is going to be a global system that any object can use you would do this in a controller object or an initialisation function run at the start of the game. The GML Code would look like this:
-global.P_System = part_system_create_layer("Instance_Layer", false);
-And using GML Visual:
-
The layer name supplied must be a valid layer in the room where the system will be used, otherwise no particles will be visible. Also note that we set the persistent flag (both in code and in GML Visual) to false. A persistent particle system is one that will "persist" across rooms without the need to destroy and re-create it for each room. However, to keep things simple for this guide, we'll not be using persistence.
-So that's the system created, but what about the particles? We have to define them too or the system is useless and does nothing.
-If you already have a Particle System Asset, you can create it using the above function/action by passing the asset into the partsys/"System" argument.
--
To use a particle in a system you have to first define its general properties. These are like object properties, but they only apply in a general way to individual particles. What this means is that if you give the particles a minimum movement speed of 1 and a maximum movement speed of 2, any particle created by the system will have a random speed between 1 and 2 pixels per step, and that overall they will have an average speed of 1.5. You should name and add your first particle to the system using the following GML in the same object that you used to create the system:
-global.Particle1 = part_type_create();
-And for those of you that use GML Visual:
-
Using GML Visual we also tick the blend option. This enables additive blending for the particle, which we'll discuss a bit further down.
-You now have a system and a particle to put in it, but you're not ready yet to create your outstanding effects! You still have to define the properties of the particle, ie: how it looks - its speed, its rotation, its alpha, etc. There are a lot of details that can be used to define a particle effect, so below is an overview of the most important settings and then a snippet of code and GML Visual that uses all of them:
-Now, before we present you the code for defining the particle, let's just talk about "wiggle" for a moment... Believe it or not, "wiggle" is a particle property and can be set for many of the above settings individually. When you see "wiggle" as an argument for a particle function or action, it means that if you place a number between 1 and 20 the particle will "wiggle" or fluctuate between the min and max values for the property, with 1 being a slow wiggle and 20 being very fast. So a particle speed minimum of 2 and maximum of 5 with a wiggle of 20 will oscillate very quickly between the min/max speeds for the lifetime of each particle created.
-There are other minor particle properties too which we don't cover here, just to keep things as simple as possible to start with. See the appropriate pages for full details of particle properties.
-Let's look at some code that defines a particle now:
-// This defines the particle's shape
- part_type_shape(global.Particle1,pt_shape_pixel);
-
- // This is for the size
- part_type_size(global.Particle1,1,1,0,2);
-
- // This sets its colour. There are three different codes for this
- part_type_color1(global.Particle1,c_white);
-
- // This is its alpha. There are three different codes for this
- part_type_alpha1(global.Particle1,1);
-
- // The particles speed
- part_type_speed(global.Particle1,0.50,2,-0.10,0);
-
- // The direction
- part_type_direction(global.Particle1,0,359,0,20);
-
- // This changes the rotation of the particle
- part_type_orientation(global.Particle1,0,0,0,0,true);
-
- // This is the blend mode, either additive or normal
- part_type_blend(global.Particle1,1);
-
- // This is its lifespan in steps
- part_type_life(global.Particle1,5,30);
-
To create this same particle definition in GML Visual we'd need these actions:
-
So that's it! We have now defined our particles and they are ready to be used.
-
Creating Particles Directly In-Game
-There are a couple of ways to create particles, and each has its pros and cons. You can use emitters to burst or stream particles, or you can create particles directly at a point. Which one you use really depends on what you are trying to achieve and the effect you are wanting to create, but we'll start with the easiest of the two, which is creating particles directly. In GML we'd use the following function:
-part_particles_create(global.P_System, x, y, global.Particle1, 10);
-and in GML Visual it'd be:
-
That single code/action above will create 10 particles at the given x/y coordinates of type "Particle1" from our global system. Simple! The great thing about that line of code/action is that it can be used anywhere without any fuss. For example if you place it in the Global Left Pressed event for the mouse in an object and change x/y values for the mouse_x/y position, it will create particles at the mouse position every time you press the button. Or if you have a rocket, then you could place this in the step event and have smoke particles coming every step (although 1 or 2 would probably be better than 10!). You can even have it create particles over an area by changing the x/y coordinates randomly, for example:
repeat(50)
- {
- var xx = x + 20 - random(40);
- var yy = y + 20 - random(40);
- part_particles_create(global.P_System, xx, yy, global.Particle1, 1);
- }
The above code will create 50 particles at a random position within a 40px square area.
-
Creating Particles With Emitters
-Since we've explained the easy way to create particles, let's now go the slightly more complex way, which is to use emitters. Emitters are another part of the particle system that has to be defined before being used, so we'll make a global emitter the same as we did for the system and the particles. We also have to decide whether to have a static (non-moving) emitter or not and whether we are going to burst or stream the particles, as well as decide over what area and what kind of distribution we are going to have the emitter use.
-What does all that mean? Well, a static emitter is one that you can define once and forget about as it will not be moving anywhere for the duration of the game, ie: think of a log fire - it doesn't move, it just emits flames and so is static, but a fireball would require a dynamic emitter and will move across the screen. As for bursting or streaming, a burst is a one off explosion of particles, whereas a stream is just that - a constant stream of particles every step. For area and distribution, with emitters you can define an area for emitting particles (which can be a rectangle, ellipse, diamond or line) as well as the distribution curve (gaussian, inverse gaussian, or linear).
-The following images illustrate the different types of area shape available for emitters:
--
- And the distribution curves (linear, gaussian, and inverse gaussian) are illustrated here:
Below is an example of the code/actions required to define two emitters, which would normally go in the Create Event of a controller object, just after defining the particle system. One will be static and stream particles over the area of the whole room, while the other will be dynamic and follow the mouse and burst every 30 steps from a small ellipse:
--
global.Particle1_Emitter1 = part_emitter_create(global.P_System);
- global.Particle1_Emitter2 = part_emitter_create(global.P_System);
-
- // Set up the area that will emit particles
- part_emitter_region(global.P_System, global.Particle1_Emitter1, 0, room_width, 0, room_height, ps_shape_rectangle, ps_distr_linear);
- part_emitter_region(global.P_System, global.Particle1_Emitter2, mouse_x-10, mouse_x+10, mouse_y-10, mouse_y+10, ps_shape_ellipse, ps_distr_gaussian);
-
- // Set the first to stream 10 particles every step
- part_emitter_stream(global.P_System, global.Particle1_Emitter1, global.Particle1, 10);
-
- // This can now be forgotten as it will function until told to stop...
- // Set the alarm[0] event to burst the emitter2 particles...
- alarm[0] = 30;
-
So, here we are creating two particle emitters that are assigned to the particle system we created at the start. The functions/actions to create these emitters permit us to define an area in the room over which they will emit particles, as well as give the particle type to emit, and the shape and distribution to use within the defined area. The functions/actions will return a numeric value, which is the emitter ID value, and we store this in a variable so that we can use further emitter functions to target those emitters.
Now we have code/GML Visual to stream particles (these particles will be emitted every game step without us having to anything else), but we also want to add an Alarm[0] Event to burst particles at specific intervals:
-part_emitter_region(global.P_System, global.Particle1_Emitter2, mouse_x - 10, mouse_x + 10, mouse_y - 10, mouse_y + 10, ps_shape_ellipse, ps_distr_gaussian);
- part_emitter_burst(global.P_System, global.Particle1_Emitter2, global.Particle1, 30);
- alarm[0] = 30;
A particle burst is simply a one-off explosion of particles from the emitter, rather than a constant stream of them every game step.
But what if you want several objects to emit particles? A global emitter can only be in one place at a time, so you would need to create local emitters in each object. These emitters will still use the global particle system and any particles that are within it, but they can be different shapes and sizes and move with the object, making them ideal for rockets or bullets or things. The code you would use is exactly the same as above, but without the "global" prefix before the emitter names.
-That's the creation of particles dealt with but there is one more thing that's very important... Cleaning up when you are finished with them.
--
As mentioned at the start, once created, a particle system (and its particles, emitters, etc.) are stored in memory for instant use. Great, but what happens when you restart the game? Or if your player dies and starts the room again? Well, if you don't manage the game right you get a memory leak. This is when something has been created and uses up memory, but has been "de-referenced" meaning that GameMaker no longer has access to it. This kind of thing will slowly eat up memory and cause lag in your game or even block the computer causing your game to crash, and it is a pretty common problem with first time users of particle systems.
-How do you avoid this? Well, GameMaker has GML Code functions and GML Visual actions to delete particle systems and their emitters and particles from memory when not in use, and with a little bit of planning when using the following code/actions, you can easily prevent this potential problem.
-The first thing you have to do is decide where you are going to create the system and how you will use it. You could create a global system in the Game Start Event of an object that is in your first room (like a menu or title screen), but this means that if you restart the game using the game_restart function, it will be recreated and cause a memory leak. Or you could create a local system in an instance in any room, but again, if you leave the room then the system will be inaccessible and cause a memory leak. To avoid this you would need to have something like this in the Game End Event or the Clean Up Event of your object:
-part_type_destroy(global.Particle1);
- part_emitter_destroy(global.P_System, global.Particle1_Emitter);
- part_emitter_destroy(global.P_System, global.Particle2_Emitter);
- part_system_destroy(global.P_System);
This will remove the defined particles, emitters, and then the system from memory ready for you to restart the game or change room. Just remember that after thinking about where would be the most suitable place to create the system, think about where would be the most suitable place to destroy the system too!
-
-
Now you know the basics about particles, particle systems and emitters, so you can now add them into your game! But before rushing off and adding particle effects to everything, please note that while particles are less CPU hungry than instances, they are not the solution to everything as they will cause lag if you have thousands of them at a time. The best thing to do is experiment and use them carefully to "flesh out" visually a game and give it a bit more eye-candy without over doing it.
--
-
Ten przewodnik jest dla tych z Was, którzy chcą zrozumieć, jak używać i tworzyć cząsteczki. Na tej stronie omówione zostaną zarówno funkcje języka GameMaker, jak i akcje wizualne GML dla cząsteczek. Jeśli nigdy wcześniej nie używałeś cząsteczek, mamy nadzieję, że ten przewodnik pomoże ci zacząć, ponieważ są one bardzo przydatne i całkiem zabawne w tworzeniu.
+Zanim przejdziemy dalej, powinniśmy wyjaśnić, czym właściwie jest cząstka... Zasadniczo cząstka to zasób graficzny, który ma pewne właściwości zdefiniowane przez system cząstek. Właściwościami tymi nie można manipulować bezpośrednio w przypadku pojedynczych cząstek, ale są one zmieniane zbiorczo za pomocą kodu lub akcji, które są używane do zdefiniowania systemu, do którego cząstka należy. Są one bardzo przydatne do tworzenia w grze pięknych i krzykliwych efektów lub subtelnych i dyskretnych efektów bez narzutu na procesor, jaki powoduje używanie instancji.
+Wspomnieliśmy już o systemach cząsteczek, więc zanim przejdziemy dalej, wyjaśnijmy, co to jest. Pomyśl o systemie cząsteczek jak o pojemniku, w którym przechowujesz cząsteczki gotowe do użycia. Możesz użyć kodu lub akcji, aby zdefiniować wizualny aspekt cząsteczek, a następnie umieścić je w "pojemniku" (systemie cząsteczek), abyś mógł je wyjąć i użyć w dowolnym miejscu i czasie.
+Przed skonfigurowaniem systemu i stworzeniem cząsteczek warto wiedzieć kilka rzeczy... Po pierwsze, większość kodu systemu cząsteczek jest wywoływana tylko raz w grze, zwykle w jakimś kontrolerze object na pierwszym room lub poziomie - nie zawsze tak jest, ale dla uproszczenia w dalszej części poradnika użyjemy tego scenariusza, ponieważ jest to najczęstszy sposób używania cząsteczek. Robisz to, ponieważ system cząsteczek, raz utworzony, pozostaje w pamięci i jest gotowy do użycia w każdej chwili, więc jeśli utworzysz go więcej niż raz, może to szybko zwiększyć wykorzystanie pamięci i spowodować poważne opóźnienia, a nawet może spowodować awarię gry. Dla uproszczenia w tym poradniku utworzysz globalny system cząsteczek, który będzie mógł być używany przez dowolną instancję w grze w dowolnym momencie.
++ +
Na początek należy zdefiniować system cząsteczek i nadać mu nazwę, aby można było z niego korzystać. Ponieważ ma to być system globalny, z którego będzie mógł korzystać każdy object, należy to zrobić w kontrolerze object lub w funkcji inicjalizacyjnej uruchamianej na początku gry. Strona GML wygląda następująco:
+global.P_System = part_system_create_layer("Instance_Layer", false);
+I przy użyciu strony GML Visual:
+Należy pamiętać, że podana nazwa warstwy musi być poprawną warstwą w witrynie room, w której system będzie używany, w przeciwnym razie nie będą widoczne żadne cząsteczki. Zauważ też, że ustawiliśmy wartość "persistent" flag (zarówno w kodzie, jak i na stronie GML Visual) na false. Trwały system cząsteczek to taki, który "przetrwa" w różnych miejscach rooms bez potrzeby niszczenia i ponownego tworzenia go dla każdej strony room. Aby jednak zachować prostotę, w tym poradniku nie będziemy używać trwałości.
Tak oto powstał system, ale co z cząstkami? Je też musimy zdefiniować, bo inaczej system jest bezużyteczny i nic nie robi.
++
Aby użyć cząstki w systemie, trzeba najpierw zdefiniować jej ogólne właściwości. Są one podobne do właściwości object, ale odnoszą się tylko w sposób ogólny do poszczególnych cząstek. Oznacza to, że jeśli nadasz cząsteczkom minimalną prędkość ruchu równą 1 i maksymalną 2, to każda cząsteczka utworzona przez system będzie miała losową prędkość między 1 a 2 piksele na krok, a ogólnie rzecz biorąc, jej średnia prędkość wyniesie 1,5. Powinieneś nazwać i dodać do systemu swoją pierwszą cząstkę, korzystając z poniższego adresu GML w tym samym object, którego użyłeś do utworzenia systemu:
+global.Particle1 = part_type_create();
+A dla tych z Was, którzy używają strony GML Visual:
+Zauważ, że korzystając z witryny GML Visual, zaznaczamy także opcję mieszania . Umożliwia to mieszanie addytywne dla cząstek, które omówimy nieco dalej.
Masz już system i cząsteczkę, którą możesz w nim umieścić, ale nie jesteś jeszcze gotowy do tworzenia wspaniałych efektów! Musisz jeszcze zdefiniować właściwości cząstki, czyli jej wygląd - prędkość, obrót, alfa itd. Istnieje wiele szczegółów, których można użyć do zdefiniowania efektu cząsteczkowego, dlatego poniżej znajduje się przegląd najważniejszych ustawień, a następnie fragment kodu i strona GML Visual, które wykorzystują wszystkie te ustawienia:
+Zanim przedstawimy kod definiujący cząsteczkę, porozmawiajmy przez chwilę o "wiggle"... Wierzcie lub nie, ale "wiggle" jest właściwością cząstki i można ją ustawić dla wielu z powyższych ustawień indywidualnie. Gdy widzisz "wiggle" jako argument funkcji lub akcji cząsteczki, oznacza to, że jeśli wpiszesz liczbę z przedziału od 1 do 20, cząsteczka będzie "wiggle" lub będzie się wahać między minimalną a maksymalną wartością tej właściwości, przy czym 1 oznacza powolne wiggle, a 20 - bardzo szybkie. Zatem minimalna prędkość cząstki równa 2, maksymalna 5, a prędkość ruchu równa 20, będzie bardzo szybko oscylować między prędkościami minimalną i maksymalną w czasie życia każdej utworzonej cząstki.
+UWAGA: Istnieją także inne, pomniejsze właściwości cząsteczek, których tutaj nie opisujemy, aby na początek wszystko było jak najprostsze. Szczegółowe informacje o właściwościach cząsteczek można znaleźć na odpowiednich stronach.
+Przyjrzyjmy się teraz kodowi, który definiuje cząstkę:
+// This defines the particle's shape
+
+ part_type_shape(global.Particle1,pt_shape_pixel);
+
+
+ // This is for the size
+
+ part_type_size(global.Particle1,1,1,0,2);
+
+
+ // This sets its colour. There are three different codes for this
+
+ part_type_color1(global.Particle1,c_white);
+
+
+ // This is its alpha. There are three different codes for this
+
+ part_type_alpha1(global.Particle1,1);
+
+
+ // The particles speed
+
+ part_type_speed(global.Particle1,0.50,2,-0.10,0);
+
+
+ // The direction
+
+ part_type_direction(global.Particle1,0,359,0,20);
+
+
+ // This changes the rotation of the particle
+
+ part_type_orientation(global.Particle1,0,0,0,0,true);
+
+
+ // This is the blend mode, either additive or normal
+
+ part_type_blend(global.Particle1,1);
+
+
+ // This is its lifespan in steps
+
+ part_type_life(global.Particle1,5,30);
Aby utworzyć taką samą definicję cząstki w witrynie GML Visual, potrzebne są następujące działania:
+I to już wszystko! Zdefiniowaliśmy nasze cząstki i są one gotowe do użycia.
+
Tworzenie cząsteczek bezpośrednio w grze
+Cząstki można tworzyć na kilka sposobów, a każdy z nich ma swoje wady i zalety. Można użyć emiterów do wybuchu lub strumienia cząstek, można też tworzyć cząstki bezpośrednio w punkcie. To, którego z nich użyjesz, zależy od tego, co chcesz osiągnąć i jaki efekt chcesz uzyskać, ale zaczniemy od najprostszego z nich, czyli od bezpośredniego tworzenia cząstek. W witrynie GML użylibyśmy następującej funkcji:
+part_particles_create(global.P_System, x, y, global.Particle1, 10);
+a w GML Visual byłoby to:
+Ten pojedynczy kod/akcja utworzy 10 cząstek w podanych współrzędnych x/y typu "Cząstka1" z naszego globalnego systemu. Proste! Wspaniałą rzeczą w tej linii kodu/akcji jest to, że może być użyta gdziekolwiek bez żadnego zamieszania. Na przykład, jeśli umieścisz ją w globalnym zdarzeniu naciśnięcia lewego przycisku myszy w object i zmienisz wartości x/y dla pozycji mouse_x/y, będzie ona tworzyć cząsteczki w pozycji myszy za każdym razem, gdy naciśniesz przycisk. Jeśli masz rakietę, możesz umieścić to w zdarzeniu kroku i mieć cząsteczki dymu pojawiające się co krok (choć 1 lub 2 byłyby lepsze niż 10!). Można nawet zlecić tworzenie cząsteczek na pewnym obszarze, na przykład zmieniając losowo współrzędne x/y:
repeat(50)
+
+ {
+
+ var xx = x + 20 - random(40);
+
+ var yy = y + 20 - random(40);
+
+ part_particles_create(global.P_System, xx, yy, global.Particle1, 1);
+
+ }
Powyższy kod utworzy 50 cząstek w losowym miejscu kwadratowego obszaru o boku 40px.
+
Tworzenie cząstek za pomocą emiterów
+Skoro wyjaśniliśmy już prosty sposób tworzenia cząstek, przejdźmy teraz do nieco bardziej skomplikowanej metody, czyli do użycia emiterów. Emitery to kolejna część systemu cząsteczek, która musi być zdefiniowana przed użyciem, więc stworzymy globalny emiter, tak samo jak zrobiliśmy to dla systemu i cząsteczek. Musimy także zdecydować, czy emiter ma być statyczny (nie poruszający się), czy też nie, oraz czy cząstki mają być rozsadzane czy strumieniowane , a także na jakim obszarze i w jakim rozkładzie emiter ma być używany.
+Co to wszystko oznacza? Cóż, emiter statyczny to taki, który można zdefiniować raz i zapomnieć o nim, ponieważ nie będzie się nigdzie poruszał przez cały czas trwania gry, np. pomyśl o ognisku z polan - nie porusza się, tylko emituje płomienie, więc jest statyczny, ale kula ognia wymaga emitora dynamicznego i będzie się poruszać po ekranie. Jeśli chodzi o wybuch lub strumień, to wybuch jest jednorazową eksplozją cząstek, podczas gdy strumień jest właśnie tym - stałym strumieniem cząstek na każdym kroku. Jeśli chodzi o obszar i rozmieszczenie, w emiterach można zdefiniować obszar emisji cząstek (może to być prostokąt, elipsa, romb lub linia), a także krzywą rozmieszczenia (gaussian, inverse gaussian lub liniowa).
+Na poniższych ilustracjach przedstawiono różne rodzaje kształtu obszaru dostępne dla emiterów:
++
+
+ Krzywe rozkładu (liniowa, gaussowska i odwrotna gaussowska) są przedstawione na ilustracji:
Poniżej znajduje się przykład kodu/działań wymaganych do zdefiniowania dwóch emiterów, które normalnie zostałyby umieszczone w zdarzeniu Create Event kontrolera object, zaraz po zdefiniowaniu systemu cząsteczek. Jeden z nich będzie statyczny i będzie rozsiewał cząsteczki na obszarze całej strony room, a drugi będzie dynamiczny i będzie podążał za myszą oraz wybuchał co 30 kroków z małej elipsy:
++
global.Particle1_Emitter1 = part_emitter_create(global.P_System);
+
+ global.Particle1_Emitter2 = part_emitter_create(global.P_System);
+
+
+ // Set up the area that will emit particles
+
+ part_emitter_region(global.P_System, global.Particle1_Emitter1, 0, room_width, 0, room_height, ps_shape_rectangle, ps_distr_linear);
+
+ part_emitter_region(global.P_System, global.Particle1_Emitter2, mouse_x-10, mouse_x+10, mouse_y-10, mouse_y+10, ps_shape_ellipse, ps_distr_gaussian);
+
+
+ // Set the first to stream 10 particles every step
+
+ part_emitter_stream(global.P_System, global.Particle1_Emitter1, global.Particle1, 10);
+
+
+ // This can now be forgotten as it will function until told to stop...
+
+ // Set the alarm[0] event to burst the emitter2 particles...
+
+ alarm[0] = 30;
Tworzymy więc dwa emitery cząsteczek, które są przypisane do systemu cząsteczek utworzonego na początku. Funkcje/akcje tworzące te emitery pozwalają nam określić obszar w witrynie room, na którym będą emitować cząstki, a także podać typ cząstek, które mają emitować, oraz kształt i rozmieszczenie, jakie mają być zastosowane w określonym obszarze. Funkcje/działania zwracają wartość liczbową, która jest identyfikatorem emitera, i przechowują ją w zmiennej, abyśmy mogli użyć kolejnych funkcji emitera do wycelowania w te emitery.
Teraz mamy kod/GML Visual do strumieniowania cząstek (cząstki te będą emitowane w każdym kroku gry, bez konieczności robienia czegokolwiek innego), ale chcemy też dodać zdarzenieAlarm[0], aby cząstki wybuchały w określonych odstępach czasu:
+part_emitter_region(global.P_System, global.Particle1_Emitter2, mouse_x - 10, mouse_x + 10, mouse_y - 10, mouse_y + 10, ps_shape_ellipse, ps_distr_gaussian);
+
+ part_emitter_burst(global.P_System, global.Particle1_Emitter2, global.Particle1, 30);
+
+ alarm[0] = 30;
Wybuch cząstek to po prostu jednorazowa eksplozja cząstek z emitera, a nie ich ciągły strumień w każdym kroku gry.
Ale co zrobić, jeśli chcesz, aby kilka stron objects emitowało cząsteczki? Globalny emiter może znajdować się tylko w jednym miejscu naraz, więc trzeba by utworzyć lokalne emitery w każdym object. Emitory te nadal będą korzystać z globalnego systemu cząsteczek i wszystkich cząsteczek, które się w nim znajdują, ale mogą mieć różne kształty i rozmiary oraz poruszać się wraz z object, co czyni je idealnymi dla rakiet, pocisków i innych rzeczy. Kod, którego użyjesz, będzie dokładnie taki sam jak powyżej, ale bez przedrostka "global" przed nazwami emiterów.
+To tyle, jeśli chodzi o tworzenie cząsteczek, ale jest jeszcze jedna bardzo ważna rzecz... Sprzątanie po zakończeniu pracy z cząsteczkami.
++
Jak wspomniano na początku, raz utworzony system cząsteczek (wraz z cząsteczkami, emiterami itp.) jest zapisywany w pamięci, aby można go było natychmiast użyć. Świetnie, ale co się stanie, gdy ponownie uruchomisz grę? Albo gdy twój gracz umrze i zaczniesz grę od nowa room? Cóż, jeśli nie zarządzasz grą w odpowiedni sposób, może dojść do wycieku pamięci. Dzieje się tak, gdy coś zostało utworzone i zużywa pamięć, ale zostało "odesłane", co oznacza, że GameMaker nie ma już do tego dostępu. Takie coś będzie powoli zużywać pamięć i powodować opóźnienia w grze, a nawet blokować komputer, powodując awarię gry. Jest to dość częsty problem u początkujących użytkowników systemów cząsteczkowych.
+Jak można tego uniknąć? Cóż, GameMaker posiada funkcje kodu GML oraz akcje wizualne GML, które usuwają systemy cząsteczek oraz ich emitery i cząsteczki z pamięci, gdy nie są używane. Przy odrobinie planowania podczas używania poniższego kodu/akcji można łatwo zapobiec temu potencjalnemu problemowi.
+Pierwszą rzeczą, którą musisz zrobić, jest określenie, gdzie utworzysz system i jak będziesz go używać. Mógłbyś utworzyć globalny system w zdarzeniu startowym gry na stronie object, która znajduje się na pierwszej stronie room (np. menu lub ekran tytułowy), ale oznacza to, że po ponownym uruchomieniu gry przy użyciu funkcji game_restart() zostanie on odtworzony i spowoduje wyciek pamięci. Możesz też utworzyć system lokalny w instancji w dowolnej witrynie room, ale również w tym przypadku, jeśli opuścisz witrynę room, system będzie niedostępny i spowoduje wyciek pamięci. Aby tego uniknąć, należałoby umieścić coś takiego w pliku Zakończenie gry lub w Zdarzenie czyszczenia swojego obiektu:
+part_type_destroy(global.Particle1);
+
+ part_emitter_destroy(global.P_System, global.Particle1_Emitter);
+
+ part_emitter_destroy(global.P_System, global.Particle2_Emitter);
+
+ part_system_destroy(global.P_System);
Spowoduje to usunięcie zdefiniowanych cząsteczek, emiterów, a następnie systemu z pamięci, gotowego do ponownego uruchomienia gry lub zmiany adresu room. Pamiętaj, że po zastanowieniu się, gdzie najlepiej stworzyć system, zastanów się też, gdzie najlepiej go zniszczyć!
+
+
Teraz znasz już podstawy cząsteczek, systemów cząsteczek i emiterów, możesz więc dodać je do swojej gry! Zanim jednak zaczniesz dodawać efekty cząsteczek do wszystkiego, pamiętaj, że choć cząsteczki mniej obciążają procesor niż instancje, nie są rozwiązaniem na wszystko, ponieważ powodują lagi, jeśli masz ich tysiące naraz. Najlepiej jest eksperymentować i używać ich ostrożnie, aby "wypełnić" wizualnie grę i nadać jej nieco więcej uroku bez przesady.
++
+ -
Shaders are often used to create beautiful graphical effects in games. They are also among the most advanced features offered by GameMaker, so it is necessary that you have a basic understanding of programming and how GameMaker works before getting started with them.
-So, what is a shader? Initially they were created to provide shading for lighting (hence the name), but they are now used to produce a huge variety of effects. Shader code is similar to regular code, but it is (almost always) executed by the GPU, not the CPU. This difference comes with its own set of rules and limitations, but we’ll cover those later.
-Each shader is made up of two separate components: a vertex shader and a fragment shader (also referred to as pixel shader). Let’s start with the vertex shader. Each sprite is formed by a rectangle, but computers like to draw triangles, so those rectangles are split into two triangles (sometimes called a quad). This leaves us with six vertices (corners) per sprite, but two of those are the same one, so we should only worry about four. Now, imagine we have a for loop that goes over every vertex and executes the code inside the vertex shader for each. This allows us to change the vertex position and color before passing it over to the fragment shader since the vertex shader is executed earlier.
-Here’s how that would look:
-
For the fragment shader, you can imagine the same loop as before, but this time it goes over every single pixel in your sprite, giving you information such as location and color of that pixel. In your fragment shader code, you perform operations and calculations to determine the color of that pixel to get the effect you want. For example, if you want a shader to make your sprite be black and white, then you’d calculate which shade of grey each pixel needs to be to create the effect.
It would look something like this:
-
The reason shader code is usually executed by the GPU is that it is more efficient at it. Modern CPUs typically have between two to eight cores. Each core can perform one task at a time, so by taking advantage of multiple cores, we can perform that many tasks simultaneously. In contrast, modern GPUs can perform thousands, and even tens of thousands, of tasks running at the same time. This is helpful for shaders because we can execute the shader code of thousands of pixels concurrently. The limitation is that we only have access to the initial state of the sprite, so we don’t know about any modifications done to other pixels since we can’t know for sure the code has run on them yet.
GameMaker allows users to write shaders in GLSL (OpenGL Shader Language), HLSL (High-level Shader Language, used when working with DirectX), and GLSL ES (a subset of GLSL which is common in mobile devices). Here we are using GLSL ES as the shader language since it’s the one that provides the best compatibility across target platforms. Generally this is the one you always want to use unless you have very specific needs and understand the limitation of the other shader languages. The math and techniques should be similar between all three languages however, save for a few syntax differences here and there.
-The vertex shader is executed first, and as we explained above, it deals with vertices. It is used to calculate positions, normals, and texture coordinates. These shaders are not particularly useful in 2D, since every sprite is usually a square, but it can be used to do some skewing, scaling, etc... It becomes much more useful in 3D for lighting calculations and mesh deformations. Fragment shaders are much more interesting and are what will be covered mostly here, since the fragment shader is where we get information about our textures and can tweak the final color of each pixel in our image.
--
If you have created a shader in GameMaker, you might have noticed the following keywords in the default pass-through shader. These keywords help the shader understand the purpose and scope of each variable:
+Shadery są często używane do tworzenia pięknych efektów graficznych w grach. Należą one również do najbardziej zaawansowanych funkcji oferowanych przez GameMakera, więc konieczne jest, abyś miał podstawowe zrozumienie programowania i działania GameMakera przed rozpoczęciem pracy z nimi.
+Czym więc jest shader? Początkowo były one tworzone w celu zapewnienia cieniowania dla oświetlenia (stąd nazwa), ale obecnie są wykorzystywane do tworzenia ogromnej liczby efektów. Kod Shader jest podobny do zwykłego kodu, ale jest (prawie zawsze) wykonywany przez GPU, a nie CPU. Ta różnica wiąże się z własnym zestawem zasad i ograniczeń, ale o tym później.
+Każdy shader składa się z dwóch oddzielnych komponentów: wierzchołka shader i fragmentu shader (zwanego również pixel shader). Zacznijmy od vertex shader. Każdy sprite jest utworzony przez prostokąt, ale komputery lubią rysować trójkąty, więc te prostokąty są dzielone na dwa trójkąty (czasami nazywane quadami). To pozostawia nam sześć wierzchołków (narożników) na sprite, ale dwa z nich są takie same, więc powinniśmy się martwić tylko o cztery. Teraz wyobraźmy sobie, że mamy for loop, który przechodzi przez każdą vertex i wykonuje kod wewnątrz vertex shader dla każdego z nich. To pozwala nam zmienić pozycję i kolor vertex przed przekazaniem go do fragmentu shader, ponieważ vertex shader jest wykonywany wcześniej.
+Oto jak to by wyglądało:
+Dla fragmentu shader, możesz wyobrazić sobie ten sam loop co wcześniej, ale tym razem przechodzi przez każdy pojedynczy piksel w twoim sprite, dając ci informacje takie jak lokalizacja i kolor tego piksela. W swoim kodzie fragmentu shader wykonujesz operacje i obliczenia, aby określić kolor tego piksela, aby uzyskać pożądany efekt. Na przykład, jeśli chcesz, aby shader sprawił, że twoja sprite będzie czarno-biała, wtedy obliczysz, jaki odcień szarości musi mieć każdy piksel, aby stworzyć ten efekt.
Wyglądałoby to coś takiego:
+Powodem, dla którego kod shader jest zazwyczaj wykonywany przez GPU jest to, że jest on w tym bardziej wydajny. Nowoczesne procesory posiadają zazwyczaj od dwóch do ośmiu rdzeni. Każdy rdzeń może wykonywać jedno zadanie w tym samym czasie, więc wykorzystując wiele rdzeni, możemy wykonywać tyle zadań jednocześnie. Dla kontrastu, nowoczesne procesory graficzne mogą wykonywać tysiące, a nawet dziesiątki tysięcy zadań w tym samym czasie. Jest to pomocne dla shaders, ponieważ możemy wykonywać kod shader tysięcy pikseli jednocześnie. Ograniczeniem jest to, że mamy dostęp tylko do stanu początkowego sprite, więc nie wiemy o żadnych modyfikacjach wykonanych na innych pikselach, ponieważ nie możemy mieć pewności, że kod został jeszcze na nich uruchomiony.
UWAGA: GameMaker pozwala pisać shaders w GLSL (OpenGL Shader Language), HLSL (High-level Shader Language, używany podczas pracy z DirectX) oraz GLSL ES (podzbiór GLSL, który jest powszechny w urządzeniach mobilnych). Tutaj używamy GLSL ES jako języka shader, ponieważ jest to ten, który zapewnia najlepszą kompatybilność na platformach docelowych. Generalnie jest to ten, którego zawsze chcesz użyć, chyba że masz bardzo specyficzne potrzeby i rozumiesz ograniczenia innych języków shader. Matematyka i techniki powinny być podobne między wszystkimi trzema językami, jednak z wyjątkiem kilku różnic w składni tu i tam.
+Program vertex shader jest wykonywany jako pierwszy i jak wyjaśniliśmy powyżej, zajmuje się on wierzchołkami. Jest on używany do obliczania pozycji, normaliów i współrzędnych texture. Te shaders nie są szczególnie przydatne w 2D, ponieważ każda sprite jest zazwyczaj kwadratem, ale można je wykorzystać do wykonania pewnych przekrzywień, skalowania, itp. Staje się to znacznie bardziej przydatne w 3D do obliczeń oświetlenia i deformacji siatki. Fragmenty shaders są o wiele bardziej interesujące i to właśnie one będą tutaj głównie omawiane, ponieważ fragment shader jest miejscem, w którym otrzymujemy informacje o naszym textures i możemy dostosować ostateczny kolor każdego piksela w naszym obrazie.
++
Jeśli stworzyłeś stronę shader w GameMakerze, mogłeś zauważyć następujące słowa kluczowe w domyślnym przejściu shader. Te słowa kluczowe pomagają shader zrozumieć cel i zakres każdej zmiennej:
You'll also see the use of vec as a keyword. This is used to identify a vector variable in the shader and you'll soon see that vectors are very important when working with shaders. That is why they are implemented as a base type in GLSL. If you are unfamiliar with them, they are a mathematical term represented as a matrix with only one column. In programming, we usually represent them as an array where the number of components corresponds to the dimension. Two and three-dimensional vectors are often used for positions, texture coordinates, or colors without an alpha channel, while four-dimensional ones are used for colors with an alpha channel. We can also specify if they hold booleans, integers, or floating point values. The syntax to declare a vector is this:
+Zobaczysz również użycie vec jako słowa kluczowego. Jest ono używane do identyfikacji zmiennej wektorowej w shader i wkrótce zobaczysz, że wektory są bardzo ważne podczas pracy z shaders. Dlatego też są one zaimplementowane jako typ bazowy w GLSL. Jeśli nie jesteś z nimi zaznajomiony, są one pojęciem matematycznym reprezentowanym jako macierz z tylko jedną kolumną. W programowaniu zwykle reprezentujemy je jako tablicę, gdzie liczba składowych odpowiada wymiarowi. Dwu i trójwymiarowe wektory są często używane dla pozycji, texture współrzędnych lub kolorów bez kanału alfa, podczas gdy czterowymiarowe są używane dla kolorów z kanałem alfa. Możemy również określić, czy przechowują one wartości logiczne, całkowite czy zmiennoprzecinkowe. Składnia do zadeklarowania wektora jest taka:
vec2 firstVec; // Two-dimensional vector of floats
vec3 secondVec; // Three-dimensional vector of floats
vec4 thirdVec; // Four-dimensional vector of floats
@@ -40,43 +40,43 @@
To initialize them, we can use the constructor to create the vector. You need to provide the same number of values as the length of the vector, but you can mix and match scalars and smaller vectors to reach the target length. Here are some examples of this:
+Aby je zainicjować, możemy użyć konstruktora do utworzenia wektora. Musisz podać taką samą liczbę wartości jak długość wektora, ale możesz mieszać i dopasowywać skalary i mniejsze wektory, aby osiągnąć docelową długość. Oto kilka przykładów:
// Simple 2D vector with 2 scalar values
vec2 firstVec = vec2(2.0, 1.0);
// A 4D vector using 2 scalars and a vec2 create the 4 values
vec4 secondVec = vec4(1.0, firstVec, 0.0);
// A 3D vector using 1 component of a vec4 plus a vec2 to create the 3 values
vec3 thirdVec = vec3(secondVec.x, firstVec);
We can also assign them another vector of the same length (or swizzle the vector until it has the proper length, but we'll explain that in a moment):
+Możemy też przypisać im inny wektor o tej samej długości (lub swizzleować wektor, aż będzie miał odpowiednią długość, ale to wyjaśnimy za chwilę):
vec3 firstVec;
vec3 secondVec = firstVec;
vec4 thirdVec = secondVec.xyz;
vec2 fourthVec = thirdVec.zx;
When accessing vector components in GLSL, we have a few options. The most basic one is to treat the vector as an array and access the components using square brackets, like this:
+Podczas dostępu do składowych wektora w GLSL, mamy kilka opcji. Najbardziej podstawową jest potraktowanie wektora jako tablicy i dostęp do składowych za pomocą nawiasów kwadratowych, tak jak to:
vec4 myVec;
myVec[0] = 1.0;
myVec[1] = 0.0;
myVec[2] = 2.0;
myVec[3] = 1.0;
However, there is another way to access the components with the following syntax:
+Istnieje jednak inny sposób dostępu do komponentów z następującą składnią:
vec4 myVec;
myVec.x = 1.0;
myVec.y = 2.0;
This uses the component names inside the vector to access them. You can use x, y, z, or w, to get the first, second, third, or fourth components, respectively. We refer to this method as swizzling because the following syntax is also valid:
+Używa to nazw składowych wewnątrz wektora, aby uzyskać do nich dostęp. Możesz użyć x, y, z lub w, aby uzyskać odpowiednio pierwszą, drugą, trzecią lub czwartą składową. Określamy tę metodę jako swizzling , ponieważ następująca składnia jest również poprawna:
vec4 firstVec;
vec3 secondVec = firstVec.xyz;
vec2 thirdVec = secondVec.zy;
vec4 fourthVec = thirdVec.yxxy;
As you can see, we can use any combination of up to four letters to create a vector of that length. We cannot attempt to access a component that would be out of bounds (for example, trying to access w in secondVec or thirdVec, since they don’t have a fourth component). Also, we can repeat letters and use them in any order, as long as the vector variable it’s being assigned to is the same size as the number of letters used.
-For obvious reasons, when using swizzle to set component values, you can’t use the same component twice. For example, the below is not valid as you are trying to set the same component to two different values:
+Jak widać, możemy użyć dowolnej kombinacji do czterech liter, aby stworzyć wektor o tej długości. Nie możemy próbować uzyskać dostępu do składowej, która byłaby poza granicami (na przykład, próbując uzyskać dostęp do w w secondVec lub thirdVec, ponieważ nie mają one czwartej składowej). Możemy również powtarzać litery i używać ich w dowolnej kolejności, o ile zmienna wektorowa, do której jest przypisana, ma taki sam rozmiar jak liczba użytych liter.
+Z oczywistych powodów, kiedy używasz swizzle do ustawiania wartości komponentów, nie możesz użyć tego samego komponentu dwa razy. Na przykład poniższe nie jest poprawne, ponieważ próbujesz ustawić ten sam komponent na dwie różne wartości:
myVec.xx = vec2(2.0, 3.0);
-Last, we have been using xyzw as our swizzle mask, which is usually the case when dealing with positions. There are two more sets of masks you can use: rgba (used for colors), or stpq (used for texture coordinates). Internally, there is no difference between these masks, and we only use them to make the code clearer as to what the vector represents in that instance. Also, we can’t combine swizzle masks in the same operation, so this is invalid:
+Ostatnio używaliśmy xyzw jako naszej maski swizzle, co zwykle ma miejsce, gdy mamy do czynienia z pozycjami. Istnieją jeszcze dwa zestawy masek, których możesz użyć: rgba (używany dla kolorów), lub stpq (używany dla współrzędnych texture ). Wewnętrznie nie ma różnicy między tymi maskami, a używamy ich tylko po to, aby kod był bardziej przejrzysty, co reprezentuje wektor w danym przypadku. Ponadto nie możemy łączyć masek swizzle w tej samej operacji, więc jest to nieważne:
myVec = otherVec.ybp;
-Those were a lot of definitions and information, but knowing these things is necessary to understand shaders themselves.
--
When you create a shader in GameMaker, it will open two files for you: a vertex shader (.vsh) and a fragment shader (.fsh). This is the most basic shader you can make, which takes a sprite, reads the texture, and colors each pixel with that color. If you specify vertex colors when drawing, those colors will blend with the texture.
-Let’s go through the code for a newly created shader asset and analyze it, starting with the vertex shader.
+To było dużo definicji i informacji, ale znajomość tych rzeczy jest niezbędna do zrozumienia samego shaders.
++
Kiedy tworzysz shader w GameMakerze, otworzy on dla Ciebie dwa pliki: vertex shader (.vsh) i fragment shader (.fsh). Jest to najbardziej podstawowy shader jaki możesz stworzyć, który pobiera sprite, czyta texture i koloruje każdy piksel tym kolorem. Jeśli podczas rysowania określisz kolory vertex, kolory te zmieszają się z texture.
+Przejdźmy przez kod dla nowo utworzonego shader asset i przeanalizujmy go, zaczynając od vertex shader.
// Passthrough Vertex Shader
attribute vec3 in_Position; // (x,y,z)
//attribute vec3 in_Normal; // (x,y,z) unused in this shader.
@@ -95,14 +95,14 @@
Outside of the main function, we see some variable declarations and their qualifiers. The attributes are given to us by GameMaker. The varying ones are created by the user to pass that information over to the fragment shader. Inside the main function, we have the calculations to find the screen position of the vertex:
+Poza funkcją główną widzimy kilka deklaracji zmiennych i ich kwalifikatorów. Atrybuty są nam dane przez GameMaker. Zmienne są tworzone przez użytkownika, aby przekazać tę informację do fragmentu shader. Wewnątrz głównej funkcji mamy obliczenia, które mają na celu znalezienie pozycji wierzchołka na ekranie:
This shader should be left alone if you are not planning to play with vertex positions and it will not be used in any of the examples given below because all the effects shown will be created using the fragment shader.
-Let’s take a quick look at the fragment shader now:
+Ten shader należy zostawić w spokoju, jeśli nie planujesz bawić się pozycjami vertex i nie będzie on używany w żadnym z podanych poniżej przykładów, ponieważ wszystkie pokazane efekty zostaną stworzone przy użyciu fragmentu shader.
+Przyjrzyjmy się teraz szybko fragmentowi shader:
// Passthrough Fragment Shader
varying vec2 v_vTexcoord;
varying vec4 v_vColour;
@@ -112,28 +112,28 @@
As explained before, the idea behind a fragment shader is to return the color of the current pixel. This is done by assigning the variable gl_FragColor the final color value. The texture2D function takes a texture and a vec2 with the UV coordinates you want to check in that texture, which returns a vec4 with the color. In the pass through shader, all we are doing is grabbing the color of the texture in the coordinate of this pixel and multiplying it by the color of the vertex associated with this pixel.
-Now that we have our first shader, all we have to do to test it is create an object and assign it a sprite, then in the Draw Event of the object you set the shader like this:
+Jak wyjaśniono wcześniej, ideą fragmentu shader jest zwrócenie koloru bieżącego piksela. Odbywa się to poprzez przypisanie zmiennej gl_FragColor ostatecznej wartości koloru. Funkcja texture2D pobiera texture i vec2 ze współrzędnymi UV, które chcesz sprawdzić w tym texture, który zwraca vec4 z kolorem. W przejściu przez shader, wszystko co robimy to złapanie koloru texture we współrzędnej tego piksela i pomnożenie go przez kolor vertex związanego z tym pikselem.
+Teraz, gdy mamy nasz pierwszy shader, wszystko co musimy zrobić, aby go przetestować, to stworzyć object i przypisać mu sprite, a następnie w zdarzeniu Draw Event z object ustawić shader w taki sposób:
// Draw Event
shader_set(shdrColorOverlay);
draw_self();
shader_reset();
Every draw call we make between shader_set() and shader_reset() will have the shader applied to it. Here, we are drawing the object sprite with our passthrough shader:
-
As you might have guessed, this does not visually changing anything, as this is a simple pass-through shader. However the sections below outline some simple steps you can take to modify this and change the way the sprite will be drawn. Each of the section shows a different shader that you can create and use in your projects, explaining the steps required to create them and why we are doing things the way we are.
- +
Każde wezwanie do losowania, które wykonujemy pomiędzy shader_set() a shader_reset() będzie miało zastosowany shader. Tutaj rysujemy stronę object sprite za pomocą naszego passthrough shadera:
+Jak można się domyślić, nie zmienia to wizualnie niczego, ponieważ jest to prosty pass-through shader. Jednakże sekcje poniżej przedstawiają kilka prostych kroków, które możesz podjąć, aby zmodyfikować to i zmienić sposób, w jaki sprite będzie rysowany. Każda z sekcji pokazuje inny shader, który możesz stworzyć i wykorzystać w swoich projektach, wyjaśniając kroki wymagane do ich stworzenia i dlaczego robimy rzeczy w ten sposób.
+
We can edit the base shader now to do something different. We'll not be touching the vertex shader part, and only editing the fragment shader, and to start with we'll do a very simple operation, which is to make the shader draw the sprite using the colour red. We'll do this by simply changing the gl_FragColor to be red., like this:
+Możemy teraz edytować bazę shader, aby zrobić coś innego. Nie będziemy dotykać części vertex shader, a jedynie edytować fragment shader, a na początek wykonamy bardzo prostą operację, polegającą na tym, że shader narysuje sprite używając koloru czerwonego. Zrobimy to, zmieniając po prostu fragment gl_FragColor na czerwony, w taki sposób:
// Color Overlay Fragment Shader
void main()
{
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}
This will give us the following result:
-
Not exactly what we expected! What we need to remember is that every sprite is ultimately a rectangle, so unless we consider transparency - which we haven't - this is the result we’ll get.
In the image above, the rectangle changes size because the base sprite has had the "empty" space around it cropped automatically when it was placed on the texture page by GameMaker, so each animation frame the triangles that make it up are different sizes to fit the cropped size of the frame. If you disable this option, then you'd simply have a motionless red square on the screen.
-Above we mentioned the texture2D function, and we'll use that to grab the color at the pixel we are working on and get the transparency from it. The return value of is texture2D is a vec4, where the components are the red, green, blue, and alpha, in that order. We can access the alpha channel either by putting a period followed by an a or a w after the variable name. This corresponds to RGBA and XYZW, respectively.
-Here’s the updated code:
+Da nam to następujący wynik:
+Nie jest to dokładnie to, czego się spodziewaliśmy! Musimy pamiętać, że każdy sprite jest ostatecznie prostokątem, więc jeśli nie uwzględnimy przezroczystości - czego nie zrobiliśmy - taki wynik otrzymamy.
UWAGA: Na powyższym obrazku prostokąt zmienia rozmiar, ponieważ podstawa sprite miała "pustą" przestrzeń wokół siebie przyciętą automatycznie, gdy została umieszczona na stronie texture przez GameMaker, więc w każdej klatce animacji tworzące ją trójkąty mają inne rozmiary, aby dopasować się do przyciętego rozmiaru ramki. Jeśli wyłączysz tę opcję, będziesz miał po prostu nieruchomy czerwony kwadrat na ekranie.
+Powyżej wspomnieliśmy o funkcji texture2D i użyjemy jej do złapania koloru przy pikselu, nad którym pracujemy, i uzyskania z niego przezroczystości. Wartością zwrotną funkcji texture2D jest vec4, gdzie składowe to czerwony, zielony, niebieski i alfa, w tej kolejności. Dostęp do kanału alfa możemy uzyskać poprzez postawienie kropki, a następnie a lub w po nazwie zmiennej. Odpowiada to odpowiednio RGBA i XYZW.
+Oto zaktualizowany kod:
// Color Overlay Fragment Shader
varying vec2 v_vTexcoord;
@@ -143,36 +143,36 @@
We are now assigning a new vec4 to gl_FragColor, where the red channel is maxed, the green, and blue channels are zero, and the alpha channel is the same as the original texture. The output looks like this:
-
Now that’s what we were after! We have replaced the color of every pixel with red, but have kept the alpha channel intact.
Having to change the shader each time we want to use a different color isn’t a good idea, especially since we’d need to have a separate shader for each color we want. Instead, we will pass the color information to the shader using a uniform. To do this, we first need to get a pointer to the uniform. We will do this in the Create Event of our object that has the sprite by adding:
+Teraz przypisujemy nowy vec4 do gl_FragColor, gdzie kanał czerwony jest maksymalny, kanały zielony i niebieski są zerowe, a kanał alfa jest taki sam jak oryginalny texture. Dane wyjściowe wyglądają tak:
+Teraz to jest to, o co nam chodziło! Zamieniliśmy kolor każdego piksela na czerwony, ale zachowaliśmy nienaruszony kanał alfa.
Konieczność zmiany shader za każdym razem, gdy chcemy użyć innego koloru, nie jest dobrym pomysłem, zwłaszcza że musielibyśmy mieć osobny shader dla każdego koloru, który chcemy. Zamiast tego, przekażemy informacje o kolorze do shader używając uniformu. Aby to zrobić, musimy najpierw uzyskać wskaźnik do uniformu. Zrobimy to w zdarzeniu Create naszego object, które posiada sprite, dodając:
// Create Event
_uniColor = shader_get_uniform(shdrColorOverlay, "u_colour");
_color = [1.0, 1.0, 0.0, 1.0];
All we need to do is call shader_get_uniform() to get a pointer to the uniform. The parameters we need to pass are the shader asset name (without quotation because we want to pass the ID that GameMaker generates for us) and the name of the uniform variable inside of the shader, this time as a string. This name needs to match exactly the one inside the shader code for it to work. We have also added a colour variable so we can change it at runtime and have it remember our changes.
-Now the code in our draw event will change slightly to pass the uniform variable.
+Wszystko, co musimy zrobić, to wywołać shader_get_uniform() aby otrzymać wskaźnik do uniformu. Parametry, które musimy przekazać to nazwa shader asset (bez cudzysłowu, ponieważ chcemy przekazać identyfikator, który wygeneruje dla nas GameMaker ) oraz nazwa zmiennej uniformu wewnątrz shader, tym razem jako string. Ta nazwa musi dokładnie odpowiadać tej wewnątrz kodu shader, aby to zadziałało. Dodaliśmy również zmienną koloru, abyśmy mogli ją zmienić na stronie runtime i aby zapamiętała nasze zmiany.
+Teraz kod w naszym zdarzeniu draw zmieni się nieco, aby przekazać zmienną uniform.
// Draw Event
shader_set(shdrColorOverlay);
shader_set_uniform_f_array(_uniColor, _color);
draw_self();
shader_reset();
It’s the same code as before, but before we draw anything, we need to pass all the uniform values to the shader. In this case, we are passing the color as an array of floats. As for the shader, we will change it to include the uniform and use it, so it becomes:
+Jest to ten sam kod co wcześniej, ale zanim cokolwiek narysujemy, musimy przekazać wszystkie wartości uniformu do shader. W tym przypadku przekazujemy kolor jako tablicę floats. Jeśli chodzi o shader, zmienimy go, aby uwzględnić mundur i użyć go, więc staje się:
// Color Overlay Fragment Shader
varying vec2 v_vTexcoord;
- uniform vec4 u_colour;
+ uniform vec4 u_color;
void main()
{
vec4 texColor = texture2D(gm_BaseTexture, v_vTexcoord);
- gl_FragColor = vec4(u_colour.rgb, texColor.a);
+ gl_FragColor = vec4(u_color.rgb, texColor.a);
}
We declare a variable with the same name as in the create shader (u_colour) and we pass it as the first three components of the gl_FragColor vector, taking advantage of swizzling. If we compile again, we should see this:
-
Now the shader is much more useful and reusable. It’s up to you to add more functionality if you need it to set the color (using the variable _color) during runtime.
+
Deklarujemy zmienną o tej samej nazwie co w create shader (u_color) i przekazujemy ją jako pierwsze trzy składowe wektora gl_FragColor, korzystając ze swizzlingu. Jeśli skompilujemy ponownie, powinniśmy zobaczyć to:
+Teraz shader jest znacznie bardziej użyteczny i wielokrotnego użytku. Od ciebie zależy, czy dodasz więcej funkcjonalności, jeśli potrzebujesz jej do ustawienia koloru (za pomocą zmiennej _color) podczas runtime.
Making a black and white shader is a great way to learn more about how shaders work, and a lot of beginners start by trying to do this, since conceptually it's quite simple: get every pixel and assign it a shade of gray. But is it simple? Not quite...
-When using RGB colour, if all three components are the same value, then we get a gray tone. The naïve approach to creating a shader to use this idea would be to add all three color channels (red, green, and blue) and then divide it by three. After that you'd assigned the value to all three channels, thus creating a gray tone. Here’s what that fragment shader looks like:
+Tworzenie czarno-białej shader to świetny sposób, aby dowiedzieć się więcej o tym, jak działa shaders, a wielu początkujących zaczyna od próby zrobienia tego, ponieważ koncepcyjnie jest to dość proste: zdobądź każdy piksel i przypisz mu odcień szarości. Ale czy to jest proste? Nie do końca...
+Podczas korzystania z koloru RGB, jeśli wszystkie trzy składowe mają tę samą wartość, to otrzymujemy tonację szarą. Naiwne podejście do tworzenia shader w celu wykorzystania tego pomysłu polegałoby na dodaniu wszystkich trzech kanałów koloru (czerwonego, zielonego i niebieskiego), a następnie podzieleniu tego przez trzy. Po tym przypisałbyś wartość do wszystkich trzech kanałów, tworząc w ten sposób ton szary. Oto jak wygląda taki fragment shader:
// Black and white fragment shader
varying vec2 v_vTexcoord;
varying vec4 v_vColour;
@@ -184,14 +184,14 @@
One thing you might have noticed is that in the gl_FragColor code, we're multiplying the vec4 with something called v_vColour. This is a variable passed by the vertex shader which tells us the color of the vertex associated with this pixel. It’s always a good idea to multiply your final calculated color with the vertex color. In most cases, it won’t do anything, but if you changed the vertex color in GML, this will reflect that (by using functions such as draw_sprite_ext() or draw_sprite_general() to change the image_blend).
-As for the draw event, it’s quite simple since we don’t have a uniform to pass in:
+Jedną z rzeczy, którą mogłeś zauważyć, jest to, że w kodzie gl_FragColor mnożymy vec4 z czymś zwanym v_vColour. Jest to zmienna przekazywana przez vertex shader, która mówi nam o kolorze vertex związanym z tym pikselem. Zawsze warto pomnożyć swój ostatecznie obliczony kolor przez kolor vertex. W większości przypadków to nic nie da, ale jeśli zmieniłeś kolor vertex w GML, to będzie to odzwierciedlone (poprzez użycie funkcji takich jak draw_sprite_ext() lub draw_sprite_general() aby zmienić image_blend).
+Jeśli chodzi o zdarzenie losowania, to jest ono dość proste, ponieważ nie mamy uniformu do przekazania:
// Draw Event
shader_set(shdrBlackAndWhite);
draw_self();
shader_reset();
Let’s compile and see what we got.
-
This looks great already, right? Well, yes and no... there is a solution that is more “correct”, since instead of adding the components and dividing by three, we multiply each component by the standard NTSC values for black and white. Here’s the modified fragment shader code:
Skompilujmy i zobaczmy, co uzyskaliśmy.
+To już wygląda świetnie, prawda? Cóż, tak i nie... istnieje rozwiązanie, które jest bardziej "poprawne", ponieważ zamiast dodawać składowe i dzielić przez trzy, mnożymy każdą składową przez standardowe wartości NTSC dla czerni i bieli. Oto zmodyfikowany fragment shader kodu:
// Black and white fragment shader
varying vec2 v_vTexcoord;
@@ -202,17 +202,17 @@
We use the dot product as a shorthand for multiplying each component of texColor with the correct weights and then add them together. If you are unfamiliar with the dot product, this is essentially what’s happening:
+Iloczynu kropkowego używamy jako skrótu do pomnożenia każdego składnika texColor z odpowiednimi wagami, a następnie dodania ich razem. Jeśli nie jesteś zaznajomiony z produktem kropkowym, to jest to zasadniczo to, co się dzieje:
float gray = (texColor.r * 0.299) + (texColor.g * 0.587) + (texColor.b * 0.114);
-In the end, it looks very similar, but it’s technically more correct.
-
+
W końcu wygląda to bardzo podobnie, ale jest technicznie bardziej poprawne.
+
Our final shader example is a fun one and can be used to add life to text and buttons and other things. We'll start simple and add functionality gradually since this shader is highly customizable. There's quite a lot to cover for this one, so if you feel a bit lost or confused, please go back and re-read some of the sections above.
-The first thing we want to do is color pixels with every hue, depending on the pixel’s horizontal position. The way to do this is to set the x position to be the hue and then convert from HSV (hue, saturation, brightness) format to RGB (red, green, and blue) format. For this, we will need to write a helper function in our fragment shader that takes HSV values and returns an RGB vector. We will use a single function which does this without the need for any if statements, as using conditionals in shader code makes shaders very slow, and should be avoided.
-Here’s what the shader looks like at this stage:
+Nasz ostatni przykład shader jest zabawny i może być użyty do dodania życia do tekstu, przycisków i innych rzeczy. Zaczniemy prosto i będziemy dodawać funkcjonalność stopniowo, ponieważ ten shader jest bardzo konfigurowalny. Jest dość dużo do omówienia, więc jeśli czujesz się zagubiony lub zdezorientowany, wróć i przeczytaj ponownie niektóre z powyższych sekcji.
+Pierwszą rzeczą, którą chcemy zrobić, jest pokolorowanie pikseli z każdym odcieniem, w zależności od pozycji poziomej piksela. Sposobem na to jest ustawienie pozycji x jako odcienia, a następnie konwersja z formatu HSV (barwa, nasycenie, jasność) do formatu RGB (czerwony, zielony i niebieski). W tym celu będziemy musieli napisać funkcję pomocniczą w naszym fragmencie shader, która przyjmuje wartości HSV i zwraca wektor RGB. Użyjemy pojedynczej funkcji, która zrobi to bez potrzeby używania jakichkolwiek if deklaracji, ponieważ używanie warunkowości w kodzie shader sprawia, że shaders jest bardzo powolny i należy go unikać.
+Oto jak wygląda shader na tym etapie:
// Fragment Shader
varying vec2 v_vTexcoord;
varying vec4 v_vColour;
@@ -231,25 +231,25 @@
There's a bit more going on here than in the previous examples, but most of it should be fairly obvious to you now. First, there’s our hsv2rgb function, which takes a vec3 with our HSV colour and returns another vec3 with our RGB conversion. In the main function, we start by creating our HSV colour, where the hue is our x position, and we’ll leave the saturation and brightness as 1.0 for now. Then, we get the alpha from the texture so it only colors our sprite character and not the entire sprite rectangle (as we did in the colour overlay example, above). Lastly, we set our Fragment color to be our HSV color converted to RGB with the alpha, multiplied by the vertex color (good practice to do this always).
-As for our draw code, it is trivial at the moment:
+Dzieje się tu trochę więcej niż w poprzednich przykładach, ale większość z nich powinna być już dla Ciebie dość oczywista. Po pierwsze, jest nasza funkcja hsv2rgb, która pobiera vec3 z naszym kolorem HSV i zwraca inny vec3 z naszą konwersją RGB. W głównej funkcji zaczynamy od stworzenia naszego koloru HSV, gdzie barwa jest naszą pozycją x, a nasycenie i jasność pozostawimy na razie jako 1.0. Następnie pobieramy alfę z texture, aby pokolorować tylko naszą postać sprite, a nie cały prostokąt sprite (jak to zrobiliśmy w przykładzie z nakładaniem kolorów, powyżej). Na koniec ustawiamy nasz kolor Fragmentu jako nasz kolor HSV zamieniony na RGB z alfą, pomnożony przez kolor vertex (dobrą praktyką jest robienie tego zawsze).
+Jeśli chodzi o nasz kod losowania, to w tej chwili jest on banalny:
// Draw Event
shader_set(shdrRainbow);
draw_self();
shader_reset();
Let’s check out what we got:
-
We are close to what we want, but there’s an issue: we are not seeing all the colors at once in every frame of the animation, and the colors seem to change randomly. The reason is that we assumed that v_vTexcoord gave us the coordinates of the sprite, starting at the top-left corner (0,0) and ending in the bottom right corner (1,1), which is standard in shaders. However, for optimization, GameMaker stuffs as many textures together as it can fit in what is called a texture page, and because of that, this is how our texture actually looks:
As explained above, v_vTexcoord gives us the absolute coordinates of the sprite within this entire texture page, but what we want is a value from 0.0 to 1.0 that only covers our current sprite. This process is called normalizing (getting a value and translating it to a 0 to 1 range). To normalize our horizontal values, we need to know the values of x0 and x1 in the picture above. Luckily, GameMaker has a function that gives us the location of every corner in our sprite within the texture page. First, we need to go to the Create Event and create a uniform to pass this data over to the shader:
Sprawdźmy, co udało nam się uzyskać:
+Jesteśmy blisko tego, co chcemy, ale jest pewien problem: nie widzimy wszystkich kolorów jednocześnie w każdej klatce animacji, a kolory wydają się zmieniać losowo. Powodem tego jest to, że założyliśmy, iż v_vTexcoord podał nam współrzędne sprite, zaczynając od lewego górnego rogu (0,0) i kończąc w prawym dolnym rogu (1,1), co jest standardem w shaders. Jednakże, dla optymalizacji, GameMaker upycha tyle textures ile może zmieścić się w tak zwanej stronie tekstury, i z tego powodu tak właśnie wygląda nasz texture:
Jak wyjaśniono powyżej, v_vTexcoord daje nam bezwzględne współrzędne sprite w obrębie całej strony texture, ale to, czego chcemy, to wartość od 0,0 do 1,0, która obejmuje tylko naszą bieżącą stronę sprite. Ten proces nazywa się normalizacją (uzyskanie wartości i przetłumaczenie jej na zakres od 0 do 1). Aby znormalizować nasze wartości poziome, musimy znać wartości x0 i x1 na powyższym obrazku. Na szczęście GameMaker ma funkcję, która daje nam położenie każdego rogu w naszym sprite w obrębie strony texture. Najpierw musimy przejść do Create Event i stworzyć uniform, który przekaże te dane do shadera:
// Create Event
_uniUV = shader_get_uniform(shdrRainbow, "u_uv");
And we modify the draw event to get the values and then pass them to the shader:
+I modyfikujemy zdarzenie draw, aby uzyskać wartości, a następnie przekazać je do shadera:
// Draw Event
shader_set(shdrRainbow);
var uv = sprite_get_uvs(sprite_index, image_index);
shader_set_uniform_f(_uniUV, uv[0], uv[2]);
draw_self();
shader_reset();
The function sprite_get_uvs() takes a sprite and an index, and it returns an array with tons of information, such as the coordinates for each corner, how many pixels were cropped to optimize it, etc. We are interested in two of those values: the left and right coordinates of the sprite, which are stored in uv[0] and uv[2] respectively. In the fragment shader, we will use those values now to calculate the normalized horizontal position like this:
+Funkcja sprite_get_uvs() przyjmuje adres sprite oraz indeks i zwraca tablicę z mnóstwem informacji, takich jak współrzędne każdego rogu, ile pikseli zostało przyciętych w celu optymalizacji, itp. Nas interesują dwie z tych wartości: współrzędne lewego i prawego narożnika sprite, które są przechowywane odpowiednio w uv[0] i uv[2]. We fragmencie shader, użyjemy teraz tych wartości do obliczenia znormalizowanej pozycji poziomej w ten sposób:
// Fragment Shader
varying vec2 v_vTexcoord;
varying vec4 v_vColour;
@@ -271,20 +271,20 @@
Here we add the uniform variable at the top of the file with the same name we used in the Create Event. Next, we calculate the normalized horizontal position by translating our current x coordinate to the origin ( v_vTexcoord.x - u_uv[0]) and then we divide it by the width of the sprite to make the range from 0 to 1 (u_uv[1] - u_uv[0]).
-The result is:
-
There we go! This is exactly what we wanted. We can see every color of the spectrum inside our sprite.
You might be happy with that, but we can have some more fun with this shader. What if we added an offset to the colors based around time to produce movement? To do this, we will need two extra variables for speed and time. We will also need two more uniforms, one for each of the new variables, so the Create Event becomes:
+Tutaj dodajemy zmienną uniform na górze pliku o tej samej nazwie, której użyliśmy w zdarzeniu Create. Następnie obliczamy znormalizowaną pozycję poziomą, tłumacząc naszą bieżącą współrzędną x na oryginał ( v_vTexcoord.x - u_uv[0]), a następnie dzielimy ją przez szerokość sprite, aby uzyskać zakres od 0 do 1 (u_uv[1] - u_uv[0]).
+Wynika z tego, że:
+No i proszę! To jest dokładnie to, czego chcieliśmy. Możemy zobaczyć każdy kolor widma wewnątrz naszego sprite.
Możesz być z tego zadowolony, ale możemy mieć trochę więcej zabawy z tym shader. Co by było, gdybyśmy dodali przesunięcie do kolorów opartych wokół czasu, aby wytworzyć ruch? Aby to zrobić, będziemy potrzebować dwóch dodatkowych zmiennych dla prędkości i czasu. Będziemy również potrzebować dwóch kolejnych mundurów, po jednym dla każdej z nowych zmiennych, więc zdarzenie Create staje się:
// Create Event
_uniUV = shader_get_uniform(shdrRainbow, "u_uv");
_uniTime = shader_get_uniform(shdrRainbow, "u_time");
_uniSpeed = shader_get_uniform(shdrRainbow, "u_speed");
_time = 0;
_speed = 1.0;
We also need to increase the time every frame, so in the Step Event we add:
+Potrzebujemy też zwiększać czas co klatkę, więc w Step Event dodajemy:
// Step Event
- _time += 1 / game_get_speed(gamespeed_fps);
Let’s go to the draw event now to send these uniforms to the shader:
+ _time += 1 / room_speed; +Przejdźmy teraz do zdarzenia draw, aby wysłać te uniformy do shadera:
// Draw Event
shader_set(shdrRainbow);
var uv = sprite_get_uvs(sprite_index, image_index);
@@ -293,7 +293,7 @@
Finally, we'll go back to our shader to actually use these variables now. What we will do is multiply the speed with the time and add it to the position, like so:
+Na koniec wrócimy do naszej strony shader, aby faktycznie użyć tych zmiennych teraz. To co zrobimy to pomnożenie prędkości przez czas i dodanie tego do pozycji, w taki sposób:
// Fragment Shader
varying vec2 v_vTexcoord;
varying vec4 v_vColour;
@@ -317,8 +317,8 @@
If you did everything correctly, you should be seeing something like this:
-
To finish this shader, we will add a few more uniforms to customize it even further. The first two are to control the saturation and brightness. The next one we'll call "section" and its function is to allow the user to pass a number between zero and one to determine what percentage of the entire spectrum we see at a time. Last, we will add a variable called "mix", which will specify how much we want to mix our shader color with the original texture color (1.0 is all rainbow, 0.0 is all texture). As always, let’s start by adding the variables to the Create Event:
Jeśli zrobiłeś wszystko poprawnie, powinieneś zobaczyć coś takiego:
+Aby zakończyć ten shader, dodamy jeszcze kilka uniformów, aby jeszcze bardziej go dostosować. Pierwsze dwa mają za zadanie kontrolować nasycenie i jasność. Następny nazwiemy "section", a jego funkcją jest umożliwienie użytkownikowi przekazania liczby z przedziału od zera do jednego, aby określić, jaki procent całego spektrum widzimy w danym momencie. Na koniec dodamy zmienną o nazwie "mix", która określi, jak bardzo chcemy wymieszać nasz kolor shader z oryginalnym kolorem texture (1.0 to cała tęcza, 0.0 to cała texture). Jak zawsze, zacznijmy od dodania zmiennych do zdarzenia Create:
// Create Event
_uniUV = shader_get_uniform(shdrRainbow, "u_uv");
_uniTime = shader_get_uniform(shdrRainbow, "u_time");
@@ -335,7 +335,7 @@
Our draw event changes to include these uniforms like this:
+Nasze zdarzenie losowania zmienia się tak, że obejmuje te mundury jak:
// Draw Event
shader_set(shdrRainbow);
var uv = sprite_get_uvs(sprite_index, image_index);
@@ -348,7 +348,7 @@
As for the shader, we need to pass the saturation and brightness to the color, which will affect the color generated by our helper function. The section needs to be multiplied by our position to reduce the range. We will also grab the entire texture color, so we can calculate our final color by mixing the texture color with the RGB conversion of our color. The last parameter of the mix function determines how much of the second color we want to add. This is our final shader code:
+Jeśli chodzi o shader, musimy przekazać nasycenie i jasność do koloru, co wpłynie na kolor generowany przez naszą funkcję pomocniczą. Sekcja musi być pomnożona przez naszą pozycję, aby zmniejszyć zakres. Chwycimy również cały kolor texture, dzięki czemu będziemy mogli obliczyć nasz ostateczny kolor poprzez zmieszanie koloru texture z konwersją RGB naszego koloru. Ostatni parametr funkcji mix określa, ile drugiego koloru chcemy dodać. To jest nasz ostateczny kod shader:
// Fragment Shader
varying vec2 v_vTexcoord;
varying vec4 v_vColour;
@@ -379,22 +379,22 @@
And our final result is this!
-
+
A nasz efekt końcowy jest taki!
+
-
That's the end of this short guide and you should now have a better understanding of how shaders work and some of the uses they can be put to. You should take your time to play with the shaders you've created following this guide, and try to experiment with them do other things - how about creating a blur shader, or a shader that makes a gameboy-style monochrome screen? - since shaders are an incredibly powerful tool for adding visual complexity and style to your games.
-We would like to thank Alejandro Hitti and Amazon for permitting us to reproduce this guide. You can find the original version on the Amazon Developer Blog.
-+
+
To już koniec tego krótkiego poradnika i powinieneś teraz lepiej zrozumieć, jak działa shaders i do jakich zastosowań można je wykorzystać. Powinieneś poświęcić swój czas na zabawę z shaders, który stworzyłeś zgodnie z tym przewodnikiem, i spróbować poeksperymentować z nimi w innych celach - co powiesz na stworzenie blur shader, lub shader, który tworzy monochromatyczny ekran w stylu gameboya? - ponieważ shaders są niezwykle potężnym narzędziem do dodawania wizualnej złożoności i stylu do twoich gier.
+Chcielibyśmy podziękować Alejandro Hitti i Amazonowi za pozwolenie na odtworzenie tego przewodnika. Oryginalną wersję można znaleźć na Amazon Developer Blog.
+-
Here you can find a list of all the functions that have been made obsolete when you compare GameMaker to legacy versions of the product. The functions listed here will be converted into compatibility scripts when you import a *.yyz made with a legacy version, and you can continue to work on the project as before. However, we recommend that you revise all the compatibility scripts created in a project, and ensure that future projects use the new functions/methods of working rather than depend on these scripts.
- +Tutaj znajdziesz listę wszystkich funkcji, które stały się przestarzałe podczas porównywania GameMakera ze starszymi wersjami produktu. Wymienione tu funkcje zostaną zamienione na skrypty zgodności, gdy zaimportujesz projekt *.yyz wykonany w starszej wersji i będziesz mógł kontynuować pracę nad projektem jak dotychczas. Zalecamy jednak, abyś zrewidował wszystkie stworzone w projekcie skrypty zgodności scripts i zadbał o to, aby przyszłe projekty korzystały z nowych funkcji/metod pracy, a nie zależały od tych scripts.
+In legacy GameMaker you had a separate background resource, where you could add images to be used as backgrounds. In GameMaker all images are considered sprites, and the use you put them too will depend on the layer they are assigned to in the room. This means that there is no longer a "background" resource, and it also means that the following functions are obsolete:
-| draw_background | +rysować tło | draw_background_ext | -draw_background_ - stretched |
- draw_background_ - stretched_ext |
+ rysować_tło_ + rozciągnięty |
+ rysować_tło_ + rozciągnięty_ekst |
|
| draw_background_ - part |
- draw_background_ - part_ext |
- draw_background_ - general |
- draw_background_ - tiled |
+ rysować_tło_ + część |
+ rysować_tło_ + część_ext |
+ rysować_tło_ + ogólne |
+ rysować_tło_ + kafelki |
| draw_background_ - tiled_ext |
- background_name | -background_exists | -background_get_ - name |
+ rysować_tło_ + kafelkowy_ekst |
+ nazwa_tła | +tło_istnieje | +background_get_ + nazwa |
| draw_background | +rysować tło | draw_background_ext | -draw_background_ - stretched |
- draw_background_ - stretched_ext |
+ rysować_tło_ + rozciągnięty |
+ rysować_tło_ + rozciągnięty_ekst |
|
| background_get_ - width |
- background_get_ - height |
- background_get_ - transparent |
- background_get_ - smooth |
+ background_get_ + szerokość |
+ background_get_ + wysokość |
+ background_get_ + przejrzysty |
+ background_get_ + gładki |
| background_get_ + | background_get_ preload |
background_get_uvs | -background_get_ - texture |
- background_set_alpha_ - from_background |
- |||
| background_create_ - from_surface |
- background_create_ - color |
- background_create_ - colour |
- background_create_ + | background_get_ + tekstura |
+ background_set_alpha_ + od_tła |
+ ||
| tło_twórcze_ + z_powierzchni |
+ tło_twórcze_ + kolor |
+ tło_twórcze_ + kolor |
+ tło_twórcze_ gradient |
||||
| background_add | -background_replace | -background_add_ - alpha |
- background_replace_ - alpha |
+ tło_replace | +background_add_ + alfa |
+ tło_zastępcze_ + alfa |
|
| background_delete | -background_duplicate | -background_assign | -background_save | +tło_usuwania | +tło_duplikat | +tło_przypisania | +tło_zapisu |
| background_prefetch | -background_ + | tło_prefetch | +tło_ prefetch_multi |
- background_flush | -background_flush_ + | tło_płukania | +tło_płukania_ multi |
| room_set_background | -room_set_ - background_colour |
- + | room_set_ + tło_kolor |
+
Legacy GameMaker lso had a number of different background variables that accessed the global background array. These are no longer required in GameMaker:
-| background_ + | tło_ index[0..7] |
- background_ + | tło_ visible[0..7] |
- background_ - alpha[0..7] |
- background_ + | tło_ + alfa[0..7] |
+ tło_ blend[0..7] |
| background_x[0..7] | background_y[0..7] | -background_ - colour |
- background_ + | tło_ + kolor |
+ tło_ showcolour |
||
| background_ + | tło_ foreground[0..7] |
- background_ + | tło_ hspeed[0..7] |
- background_ + | tło_ vspeed[0..7] |
- background_ + | tło_ htiled[0..7] |
| background_ + | tło_ vtiled[0..7] |
- background_ + | tło_ width[0..7] |
- background_ + | tło_ height[0..7] |
- background_ + | tło_ xscale[0..7] |
| background_ + | tło_ yscale[0..7] |
You can find out more about Background Layers from the section on the Room Editor, and for more information on the functions that control background layers using code see Background Layers.
-+
Więcej o warstwach tła dowiesz się z rozdziału poświęconego edytorowi pomieszczeń, a więcej informacji na temat funkcji sterujących warstwami tła za pomocą kodu znajdziesz w rozdziale Warstwy tła.
+- +
As with backgrounds (explained above) the tile resource from legacy GameMaker no longer exists, and instead we have Tile Sets in GameMaker. In legacy GameMaker, tiles used a background resource and were placed at different depths in the room editor or through code, however the method used was not terribly flexible and was also not that efficient. To address these issues, in GameMaker tilesets are now created from a sprite resource, and can have various different properties (like animation or auto-tiling). They are then placed on a tilemap layer within the room editor or through code. Due to these changes the following functions are now obsolete:
-| tile_get_x | -tile_get_y | -tile_get_left | -tile_get_top | +płytka_get_x | +płytka_get_y | +płytka_get_left | +płytka_get_top |
| tile_get_width | -tile_get_height | -tile_get_depth | -tile_get_visible | +płytka_get_szerokość | +płytka_get_height | +płytka_get_depth | +płytka_get_visible |
| tile_get_xscale | -tile_get_yscale | -tile_get_alpha | -tile_get_background | +płytka_get_xscale | +płytka_uzyskana_skala | +płytka_get_alfa | +płytka_get_background |
| tile_set_visible | tile_set_background | -tile_set_region | -tile_set_position | +płytka_set_region | +płytka_set_pozycja | ||
| tile_set_depth | +płytka_set_głębokość | tile_set_scale | tile_set_blend | tile_set_alpha | |||
| tile_get_count | -tile_get_id | +płytka_get_count | +płytka_get_id | tile_get_ids | -tile_get_ids_at_depth | +płytka_get_ids_at_depth | |
| tile_add | -tile_exists | -tile_delete | -tile_layer_hide | +płytka_d | +płytka_istnieje | +płytka_usuń | +płytka_warstwa_ukrycia |
| tile_layer_show | -tile_layer_delete | -tile_layer_shift | -tile_layer_find | +płytka_warstwa_usuń | +płytka_warstwa_przesunięcie | +płytka_warstwa_znajdź | |
| tile_layer_delete_at | -tile_layer_depth | +płytka_warstwa_usuń_at | +płytka_warstwa_głębokość | room_tile_add | room_tile_add_ext |
You can find out more about Tile Sets from the manual section on the Tile Set Editor and about how to use them in the room editor from the section on Tile Layers. For more information on the functions that control background layers using code see Tilemap Layers. It is also worth noting that the GameMaker Language has some specific funtions related to using legacy tiles in imported projects, and you can find information on those here.
-+
Więcej o Tile Sets dowiesz się z sekcji podręcznika poświęconej edytorowi zestawów kafelków, a o tym, jak używać ich w edytorze room z sekcji poświęconej warstwom kafelków. Więcej informacji na temat funkcji sterujących warstwami tła za pomocą kodu znajdziesz w rozdziale Warstwy Tilemap. Warto również zauważyć, że edytor GameMaker Language ma pewne specyficzne funcje związane z używaniem starszych tiles w importowanych projektach, a informacje na ich temat można znaleźć tutaj.
+- +
The way objects are treated in GameMaker has changed slightly due to the introduction of layers in the room editor. There still exists the "depth" variable, but it is now only really used for compatibility and you can no longer get or set the depth for objects, only instances. This makes the following functions obsolete:
-| object_get_depth | +obiekt_get_depth |
| object_set_depth | +obiekt_set_głębokość |
You can find out more about object resources from the manual section on the Object Editor and on the functions that control objects using code from the section Objects.
-+
Więcej o zasobach object można dowiedzieć się z sekcji podręcznika poświęconej edytorowi obiektów, a o funkcjach sterujących objects za pomocą kodu z sekcji Obiekty.
+- +
Legacy GameMaker had two different sound API's, one which used the deprecated sound_ functions (that was only really valid for the HTML5 target platform), and the other which used the audio_ functions. The audio API has been improved and expanded in GameMaker, making the legacy functions listed below obsolete:
-| sound_name | -sound_exists | +nazwa_dźwięku | +dźwięk_istnieje | sound_get_name | sound_get_kind | ||
| sound_get_preload | -sound_exists | -sound_restore | -sound_delete | +dźwięk_istnieje | +przywrócić dźwięk | +dźwięk_skasowany | |
| sound_play | -sound_loop | -sound_stop | -sound_stop_all | +dźwięk_play | +pętla dźwiękowa | +dźwięk_stop | +dźwięk_stop_all |
| sound_isplaying | -sound_volume | -sound_fade | -sound_global_volume | +dźwięk_odtwarzania | +dźwięk_głośny | +dźwięk_fade | +dźwięk_globalny_głos |
| audio_music_gain | audio_music_is_playing | -audio_new_system | -audio_old_system | +audio_nowy_system | +audio_stary_system | ||
| audio_pause_music | +audio_pauza_muzyka | audio_play_music | audio_resume_music | audio_stop_music | @@ -295,99 +295,99 @@
You can find out more about audio resources from the manual section on the Sound Editor and on the functions that control audio using code from the section on Audio.
-+
Więcej o zasobach audio dowiesz się z sekcji podręcznika poświęconej edytorowi dźwięku, a o funkcjach sterujących dźwiękiem za pomocą kodu z sekcji Audio.
+
When using 3D models or primitives in legacy GameMaker, you had to use the d3d_ functions. These used an obsolete API for drawing and in many cases were not related strictly to Direct 3D API, or even to using 3D itself. With the advent of vertex buffers, matrices and cameras in GameMaker, the following functions have been made obsolete:
-| d3d_start | d3d_end | -d3d_set_perspective | -d3d_set_hidden | +d3d_set_perspektywa | +d3d_set_zakazany | ||
| d3d_set_depth | -d3d_set_lighting | -d3d_set_shading | +d3d_set_głębokość | +d3d_set_oświetlenie | +d3d_set_cieniowanie | d3d_set_fog | |
| d3d_set_culling | d3d_set_zwriteenable | -d3d_set_projection | +d3d_set_projekcja | d3d_set_projection_ext | |||
| d3d_set_projection_ + | d3d_set_projection_ ortho |
- d3d_set_projection_ - perspective |
- d3d_transform_set_ - identity |
- d3d_transform_ + | d3d_set_projection_ + perspektywa |
+ d3d_transform_set_ + tożsamość |
+ d3d_transform_ set_translation |
| d3d_transform_set_ - scaling |
- d3d_transform_ + | d3d_transform_set_ + skalowanie |
+ d3d_transform_ set_rotation_x |
- d3d_transform_set_ - rotation_y |
- d3d_transform_ - set_rotation_z |
- ||
| d3d_transform_set_ - rotation_axis |
- d3d_transform_ - add_translation |
- d3d_transform_add_ - scaling |
- d3d_transform_ - add_rotation_x |
- ||||
| d3d_transform_add_ - rotation_y |
- d3d_transform_ - add_rotation_z |
- d3d_transform_add_ - rotation_axis |
- d3d_transform_ + | d3d_transform_set_ + obrót_y |
+ d3d_transform_ + ustawiona_rotacja_z |
+ ||
| d3d_transform_set_ + oś obrotu |
+ d3d_transform_ + dodać_translację |
+ d3d_transform_add_ + skalowanie |
+ d3d_transform_ + dodać_rotację_x |
+ ||||
| d3d_transform_add_ + obrót_y |
+ d3d_transform_ + dodać_rotację_z |
+ d3d_transform_add_ + oś obrotu |
+ d3d_transform_ stack_clear |
||||
| d3d_transform_stack_ - empty |
- d3d_transform_ - stack_push |
- d3d_transform_stack_ + | d3d_transform_stack_ + pusty |
+ d3d_transform_ + stos_przesuwanie |
+ d3d_transform_stack_ pop |
- d3d_transform_ - stack_top |
+ d3d_transform_ + stos_górny |
| d3d_transform_stack_ - discard |
+ d3d_transform_stack_ + odrzuć |
d3d_transform_vertex | -d3d_light_define_ - ambient |
- d3d_light_define_ - direction |
+ d3d_light_define_ + otoczenia |
+ d3d_light_define_ + kierunek |
|
| d3d_light_define_point | d3d_light_enable | d3d_primitive_begin | -d3d_primitive_ - begin_texture |
+ d3d_prymitywny_ + początek_tekstury |
|||
| d3d_primitive_end | @@ -397,529 +397,513 @@|||||||
| d3d_vertex_texture | -d3d_vertex_texture_ - color |
- d3d_vertex_texture_ - colour |
+ d3d_vertex_texture_ + kolor |
+ d3d_vertex_texture_ + kolor |
d3d_vertex_normal | ||
| d3d_vertex_normal_ - color |
- d3d_vertex_normal_ - colour |
- d3d_vertex_normal_ - texture |
- d3d_vertex_normal_ - texture_color |
+ d3d_vertex_normal_ + kolor |
+ d3d_vertex_normal_ + kolor |
+ d3d_vertex_normal_ + tekstura |
+ d3d_vertex_normal_ + tekstura_kolor |
| d3d_vertex_normal_ - texture_colour |
+ d3d_vertex_normal_ + tekstura_kolor |
d3d_draw_block | d3d_draw_cylinder | d3d_draw_cone | |||
| d3d_draw_ellipsoid | +d3d_draw_elipsoid | d3d_draw_wall | d3d_draw_floor | d3d_model_create | |||
| d3d_model_destroy | +d3d_model_zniszczenie | d3d_model_clear | d3d_model_load | d3d_model_save | |||
| d3d_model_draw | -d3d_model_primitive_ + | d3d_model_prymitywny_ begin |
- d3d_model_ - primitive_end |
+ d3d_model_ + prymitywny_końcówka |
d3d_model_vertex | ||
| d3d_model_vertex_ - color |
- d3d_model_vertex_ - colour |
- d3d_model_ - vertex_texture |
- d3d_model_vertex_ - texture_color |
+ d3d_model_vertex_ + kolor |
+ d3d_model_vertex_ + kolor |
+ d3d_model_ + tekstura wierzchołka |
+ d3d_model_vertex_ + tekstura_kolor |
| d3d_model_vertex_ - texture_colour |
- d3d_model_vertex_ - normal |
- d3d_model_ + | d3d_model_vertex_ + tekstura_kolor |
+ d3d_model_vertex_ + normalna |
+ d3d_model_ vertex_normal_color |
- d3d_model_vertex_ - normal_colour |
+ d3d_model_vertex_ + normalny_kolor |
| d3d_model_vertex_ - normal_texture |
- d3d_model_vertex_ - normal_texture_color |
- d3d_model_vertex_ - normal_texture_colour |
- d3d_model_block | +d3d_model_vertex_ + normalna_tekstura |
+ d3d_model_vertex_ + normalny_kolor_tekstury |
+ d3d_model_vertex_ + normalny_kolor_tekstury |
+ d3d_model_blok |
| d3d_model_cylinder | -d3d_model_cone | -d3d_model_ellipsoid | -d3d_model_wall | +d3d_model_cylindra | +d3d_model_stożka | +d3d_model_elipsoidy | +d3d_model_ściany |
| d3d_model_floor |
You can find out more about vertex buffers here, more about matrices here, more about cameras here, and more about the GPU functions here.
-+
Więcej o vertex buffers dowiesz się tutaj, więcej o macierzach tutaj, więcej o kamerach tutaj, a więcej o funkcjach GPU tutaj.
+-
View Variables And Window Functions
+With the advent of the camera functions in GameMaker, it means that a number of view variables are no longer required, specifically those referring to the view into the room rather than the view_port (which is still used). There are also a few functions for controlling how things are displayed that were available in legacy versions of GameMaker Studio which are also no longer appropriate. These variables and functions are listed below:
-| view_object | -view_angle | -view_xview | -view_yview | +widok_obiektu | +widok_kąt | +widok_xview | +widok_yview |
| view_hview | -view_wview | -view_hborder | -view_vborder | +widok_hview | +widok_widok | +widok_brzegu | +widok_vborder |
| view_hspeed | -view_vspeed | -display_set_windows_ + | widok_prędkości | +widok_prędkości | +display_set_windows_ vertex_buffer_method |
- display_get_windows_ + | display_get_windows_ vertex_buffer_method |
| display_set_windows_ + | display_set_windows_ alternate_sync |
- display_get_windows_ + | display_get_windows_ alternate_sync |
room_set_view |
You can find out more about cameras from the manual section on Cameras And The Display.
-+
Więcej o aparatach fotograficznych dowiesz się z działu poradnika Aparaty fotograficzne i wyświetlacz.
+- +
GameMaker moves a lot of built in functionality from previous versions into extensions, meaning that the following 3rd party support functions are considered obsolete:
-| ads_enable | -ads_disable | -ads_move | -ads_get_display_ - width |
+ reklama_disable | +reklamy_ruchu | +ads_get_display_ + szerokość |
|
| ads_get_display_ - height |
- ads_interstitial_ - available |
- ads_interstitial_ - display |
- ads_setup | +ads_get_display_ + wysokość |
+ reklamy_interstitialowe + dostępny |
+ reklamy_interstitialowe + wyświetlanie |
+ reklamy_ustawienia |
| ads_engagement_ - available |
- ads_engagement_ - launch |
- ads_engagement_ - active |
- ads_event | +reklamy_zarządzania_ + dostępny |
+ reklamy_zarządzania_ + uruchomienie |
+ reklamy_zarządzania_ + aktywny |
+ reklama_zdarzenie |
| ads_event_preload | -ads_set_reward_ + | ads_set_reward_ callback |
- playhaven_add_ - notification_badge |
- playhaven_hide_ - notification_badge |
+ playhaven_add_ + plakietka powiadamiająca |
+ playhaven_hide_ + plakietka powiadamiająca |
|
| playhaven_position_ - notification_badge |
- playhaven_update_ - notification_badge |
- pocketchange_display_ - reward |
- pocketchange_display_ - shop |
+ playhaven_position_ + plakietka powiadamiająca |
+ playhaven_aktualizacja_ + plakietka z powiadomieniem |
+ pocketchange_display_ + nagroda |
+ pocketchange_display_ + sklep |
| analytics_event | +analiza_zdarzenia | analytics_event_ext | facebook_init | facebook_login | |||
| facebook_request_ - publish_permissions |
- facebook_request_ - read_permissions |
- facebook_check_ - permission |
+ facebook_prośba_ + publikacja_pozwoleń |
+ facebook_prośba_ + odczytać_pozwolenia |
+ facebook_check_ + pozwolenie |
facebook_status | |
| facebook_accesstoken | facebook_user_id | -facebook_graph_ - request |
+ facebook_graph_ + prośba |
facebook_dialog | |||
| facebook_send_invite | -facebook_post_ - message |
- facebook_logout | -facebook_launch_ - offerwall |
+ facebook_send_invite | +facebook_post_ + wiadomość |
+ facebook_logout | +facebook_launch_ + offerwall |
| iap_event_queue | -iap_files_purchased | -iap_is_downloaded | -iap_product_files | +iap_event_queue | +iap_files_purchased | +ap_is_downloaded | +iap_product_files |
| iap_product_status | -iap_store_status | -iap_data | -iap_activate | +iap_product_status | +iap_store_status | +ap_data | +iap_aktywować |
| iap_status | +ap_status | iap_enumerate_products | iap_restore_all | -iap_acquire | +ap_acquire | ||
| iap_consume | +ap_konsumpcja | iap_product_details | iap_purchase_details | -+ | |||
| immersion_play_effect | -immersion_stop | +efekt zanurzenia_play | +zanurzenie_stop | ||||
| achievement_* | +osiągnięcie_* | win8_* | uwp_appbar_* |
You can get our official extensions for advertising and other APIs from the Marketplace Page.
-+
Możesz uzyskać nasze oficjalne rozszerzenia dla reklam i innych interfejsów API ze strony Marketplace.
+- +
Both legacy GameMaker and GameMaker have a visual scripting GML Visual interface for creating your games, however the way it is handled in GameMaker is quite different to the previous methods used. Previously, all GML Visual actions had their own corresponding function which worked "behind the scenes" to get the desired results, however this was not very transparent and added in extra overheads to the function calls, resulting in poorer performance. In GameMaker this has been changed, and now all actions compile to pure code (and can be shown as such if required), meaning that the following action functions are obsolete:
-| action_path_old | -action_set_sprite | -action_draw_font | +działanie_ścieżka_dawna | +akcja_set_sprite | +akcja_draw_font | action_draw_font_old | |
| action_fill_color | -action_fill_colour | +działanie_wypełnienie_kolorem | action_line_color | -action_line_colour | +akcja_linia_koloru | ||
| action_highscore | -action_set_relative | -action_move | -action_set_motion | +działanie_wysokie wyniki | +działanie_set_relacyjne | +akcja_ruch | +akcja_ustawienie_ruchu |
| action_set_hspeed | -action_set_vspeed | -action_set_gravity | -action_set_friction | +działanie_ustawienie_prędkości | +działanie_ustawienie_prędkości | +działanie_ustawienie_grawitacji | +działanie_ustawienie_tarcia |
| action_move_point | -action_move_to | -action_move_start | -action_move_random | +akcja_przesunięcie_punktu | +działanie_przemieszczanie_do | +działanie_ruchowe_start | +akcja_ruch_losowy |
| action_snap | -action_wrap | -action_reverse_xdir | -action_reverse_ydir | +działanie_zatrzaskowe | +działanie_wrap | +działanie_odwrotne_xdir | +działanie_odwrotne_ydir |
| action_move_contact | -action_bounce | -action_path | -action_path_end | +działanie_przeniesienie_kontaktu | +akcja_odbijania | +ścieżka działania | +działanie_ścieżka_końca |
| action_path_position | -action_path_speed | -action_linear_step | -action_potential_step | +działanie_ścieżka_pozycja | +działanie_ścieżka_prędkość | +działanie_liniowe_kroku | +działanie_potencjał_kroku |
| action_kill_object | -action_create_object | -action_create_object_motion | -action_create_object_random | +działanie_zabijanie_obiektu | +akcja_tworzenia_obiektu | +akcja_tworzenia_obiektu_ruchu | +akcja_tworzenia_obiektu_losowego |
| action_change_object | -action_kill_position | -action_sprite_set | -action_sprite_transform | +akcja_zmiana_obiektu | +działanie_zabójcze_pozycja | +działanie_sprite_set | +działanie_sprite_transform |
| action_sprite_color | -action_sprite_colour | -action_sound | -action_end_sound | +akcja_sprite_colour | +działanie_dźwięk | +działanie_końca_dźwięku | |
| action_if_sound | -action_another_room | -action_current_room | -action_previous_room | +działanie_jeśli_dźwięk | +działanie_inne_pokoju | +działanie_bieżące_pokoju | +działanie_poprzednie_pokoju |
| action_next_room | -action_if_previous_room | -action_if_next_room | -action_set_alarm | +akcja_następna_pokoju | +działanie_jeśli_poprzedni_pokój | +działanie_jeśli_następny_pokój | +działanie_ustawione_alarm |
| action_sleep | -action_set_timeline | +działanie_spokojne | +akcja_set_timeline | action_timeline_set | -action_timeline_start | +działanie_terminowe_start | |
| action_timeline_stop | -action_timeline_pause | +działanie_czasowe_stop | +akcja_czasowa_pauza | action_set_timeline_position | action_set_timeline_speed | ||
| action_message | -action_show_info | -action_show_video | -action_end_game | +akcja_komunikat | +akcja_pokaz_info | +akcja_pokaz_wideo | +akcja_końca_gry |
| action_restart_game | -action_save_game | -action_load_game | -action_replace_sprite | +akcja_restart_gry | +akcja_zapisywania_gry | +akcja_load_gry | +akcja_wymiana_sprintu |
| action_replace_sound | -action_replace_ - background |
- action_if_empty | -action_if_collision | +działanie_zastępcze_dźwięk | +czynność_zastępcza_ + tło |
+ działanie_jeśli_puste | +działanie_jeśli_zderzenie |
| action_if | -action_if_number | -action_if_object | -action_if_question | +działanie_jeśli | +działanie_jeśli_numer | +działanie_jeśli_obiekt | +działanie_jeśli_pytanie |
| action_if_dice | -action_if_mouse | -action_if_aligned | -action_execute_script | +działanie_jeśli_kość | +akcja_jeśli_mysz | +działanie_jeśli_wyrównane | +akcja_wykonaj_script |
| action_inherited | -action_if_variable | -action_draw_variable | -action_set_score | +działanie_dziedziczone | +działanie_jeśli_zmienna | +akcja_draw_zmienna | +akcja_set_score |
| action_if_score | -action_draw_score | -action_highscore_show | -action_highscore_clear | +działanie_jeśli_wynik | +akcja_wyciąganie_wyników | +działanie_wysokie_wyniki_pokaz | +działanie_wysoki_wynik_clear |
| action_set_life | -action_if_life | -action_draw_life | -action_draw_life_images | +działanie_ustawione_na_życie | +działanie_jeśli_życie | +akcja_rysowanie_życia | +akcja_draw_life_images |
| action_set_health | -action_if_health | -action_draw_health | -action_set_caption | +działanie_set_zdrowie | +działanie_jeśli_zdrowie | +akcja_rysuj_zdrowie | +akcja_set_caption |
| action_partsyst_create | -action_partsyst_destroy | -action_partsyst_clear | +działanie_partyzant_tworzy | +działanie_parametru_zniszczenie | +działanie_parametru_clear | action_parttype_create_old | |
| action_parttype_create | +akcja_typu_tworzenia | action_parttype_color | action_parttype_colour | -action_parttype_life | +działanie_typu_życia | ||
| action_parttype_speed | -action_parttype_gravity | -action_parttype_secondary | -action_partemit_create | +działanie_rodzaj_prędkości | +działanie_typ_grawitacji | +rodzaj_działania_podstawowego | +działanie_partemit_create |
| action_partemit_destroy | -action_partemit_burst | -action_partemit_stream | -action_cd_play | +działanie_partemit_niszczy | +działanie_partemit_burst | +działanie_partemit_stream | +działanie_cd_play |
| action_cd_stop | -action_cd_pause | -action_cd_resume | -action_cd_present | +działanie_cd_stop | +działanie_cd_pauza | +działanie_cd_wznowienie | +działanie_cd_obecne |
| action_cd_playing | -action_set_cursor | -action_webpage | -action_splash_web | +działanie_cd_odtwarzanie | +akcja_set_kursor | +akcja_strona | +akcja_splash_web |
| action_draw_sprite | -action_draw_background | -action_draw_text | -action_draw_text_transformed | +akcja_draw_sprite | +akcja_draw_background | +akcja_rysuj_tekst | +akcja_draw_text_transformed |
| action_draw_rectangle | +akcja_rysuj_prostokąt | action_draw_gradient_hor | -action_draw_gradient_vert | -action_draw_ellipse | +akcja_draw_gradient_vert | +akcja_rysuj_elipsę | |
| action_draw_ - ellipse_gradient |
- action_draw_line | -action_draw_arrow | -action_color | +akcja_rysuj_ + elipsa_gradient |
+ akcja_rysuj_linię | +akcja_wyciągnij_strzałkę | +akcja_kolor |
| action_colour | +akcja_kolor | action_font | -action_fullscreen | -action_snapshot | +akcja_fullscreen | +akcja_zrzut | |
| action_effect | +działanie_skutek |
You can find out more about the new GML Visual from the manual section on GML Visual.
-+
Więcej o nowym GML Visual można dowiedzieć się z sekcji podręcznika poświęconej GML Visual.
+- -
The data type used to store vectors and matrices in GameMaker are Arrays. Therefore, the following functions relating to working with vectors and matrices were removed:
-| is_vec3 | -is_vec4 | -is_matrix | -
These functions appeared to check for a specific type, while the underlying type is always an array or a range of an array (of respectively length 3, 4 and 16). E.g. the functions matrix_build and matrix_build_identity return a matrix, of which the 16 elements are stored in an array datatype. To check the datatype you should use is_array instead and combine this with the length of the array given by array_length to work out the datatype.
-Checking for an array datatype and its length doesn't mean the actual contents represent a valid vector or matrix.
-Alternatively, to store vectors and matrices you can use other data structures provided by GameMaker, such as Buffers, DS Grids a struct or even a surface to store the same information, instead of a dedicated data type.
--
The following built-in global variables are also obsolete, although they are still considered reserved variables in GML so that the IDE can recognise them and flag them for updating/removing when a legacy project that uses them is imported (as are the variables listed under the Views and the Backgrounds sections, above):
++
Następujące wbudowane zmienne globalne są również przestarzałe, chociaż nadal są uważane za zarezerwowane zmienne w GML, tak aby IDE mógł je rozpoznać i flag w celu aktualizacji/usunięcia, gdy starszy projekt, który ich używa, jest importowany (podobnie jak zmienne wymienione w sekcjach Widoki i Tła, powyżej):
| gamemaker_registered | -gamemaker_progamemaker_ - version |
+ gamer_zarejestrowany | +gamemaker_progamemaker_ + wersja |
secure_mode | |
| show_health | -show_score | -show_lives | +pokaż_zdrowie | +pokaż_wynik | +pokaz_życia |
| caption_score | -caption_lives | -caption_health | +napis_żyje | +napis_zdrowie | |
| argument_relative | -room_caption | -room_speed | +argument_relatywny | +pomieszczenie_zakaptuł | +prędkość pomieszczenia |
| transition_steps | -transition_kind | -game_guid | +przejście_kroków | +rodzaj przejścia | +identyfikator gry |
| error_last | -error_occurred | +błąd_ostatni | +wystąpił błąd | buffer_surface_copy |
-
-
+
+
+
-
When using the file system functions or included files with GameMaker it is vitally important to know exactly how the file system works and what things are going on behind the scenes. To that end, this section is designed to explain and clarify exactly how things are stored, where they are stored and what possible limits or workarounds there may be to this system.
-The first and most important thing to note about the file functions is that they are limited - in general and by default - to the sandbox. What this means is that GameMaker cannot save or load files from anywhere that is not part of the game bundle or the local storage for the device without explicit input from the user, and even then this input is limited to only Windows, macOS and Ubuntu (Linux) target platforms.
-It is possible to turn off the sandboxing, however, on the Desktop targets (Windows, macOS, and Ubuntu (Linux)) by checking the Disable file system sandbox option in the Game Options for the target platform. You do this at your own risk, and while this will open up file saving and loading and permit you to access files anywhere on the given system, it may still be limited by the OS permissions, and you will not be able to write to the program_directory folder.
-To understand the sandbox first of all you need to understand that there are two distinct areas for files:
+Podczas korzystania z funkcji systemu plików lub dołączonych plików w programie GameMaker niezwykle ważna jest dokładna znajomość + jak działa system plików i co dzieje się za kulisami. W tym celu ten rozdział ma za zadanie wyjaśnić i objaśnić dokładnie, jak rzeczy są przechowywane, gdzie są przechowywane i jakie są możliwe ograniczenia lub obejścia tego systemu. + w tym systemie.
+Pierwszą i najważniejszą rzeczą, na którą należy zwrócić uwagę w przypadku funkcji plików, jest to, że są one ograniczone - ogólnie i domyślnie - do piaskownicy. Oznacza to, że GameMaker nie może zapisywać ani wczytywać plików z dowolnego miejsca, które nie jest częścią pakietu gry lub pamięci lokalnej urządzenia, bez wyraźnego polecenia użytkownika, a nawet wtedy polecenie to jest ograniczone tylko do platform docelowych Windows, macOS i Ubuntu (Linux).
+WAŻNE! Na platformach docelowych Desktop (Windows, macOS oraz Ubuntu (Linux)) można jednak wyłączyć piaskownicę, zaznaczając opcję Disable file system sandbox (Wyłącz piaskownicę systemu plików ) w opcjach gry dla platformy docelowej. Robisz to na własne ryzyko i chociaż otworzy to możliwość zapisywania i wczytywania plików oraz umożliwi dostęp do plików w dowolnym miejscu w systemie, może to być nadal ograniczone przez uprawnienia systemu operacyjnego i nie będzie można zapisywać + do program_katalog folderu.
+Aby zrozumieć działanie piaskownicy, należy przede wszystkim zrozumieć, że istnieją dwa odrębne obszary dla plików:
The following diagram may help you to visualise this better:
+Poniższy schemat może pomóc w lepszej wizualizacji tego zjawiska:
You can never write to the File Bundle (program) directory.
-When your game is sandboxed, the two target areas - the bundle directory and the local storage area - are available on each target platform, but on each one they will work slightly differently. However GameMaker has abstracted out the main essence of what can and can't be done, making it easier to re-target games to multiple environments.
-To start with, you should understand what is meant when we talk of the working_directory. This is a synonym for the two possible save locations (as illustrated by the diagram above) and when you use that directory it will do one of two things depending on whether you are reading or writing, and whether the file you are reading from has been changed or not:
+UWAGA: Nigdy nie można zapisywać w katalogu File Bundle (program).
+Gdy gra jest sandboxowana, dwa docelowe obszary - katalog bundle i lokalny obszar przechowywania - są dostępne na każdej platformie docelowej, ale na każdej z nich będą działać nieco inaczej. Jednak GameMaker wyabstrahował główną + co można, a czego nie można zrobić, ułatwiając w ten sposób dostosowanie gry do wielu środowisk.
+Na początek należy zrozumieć, co mamy na myśli, gdy mówimy o working_directory. Jest to synonim dwóch + możliwych miejsc zapisu (jak pokazano na powyższym diagramie) i kiedy użyjesz tego katalogu, zrobi on jedną z dwóch rzeczy, w zależności od tego, czy czytasz, czy piszesz, oraz od tego, czy plik, z którego czytasz, został zmieniony, czy nie:
in general GameMaker will handle all this for you and you rarely need to use the working_directory built in variable.
-Using these two simple rules we can now see how the following functions work (these are examples to help you to visualise the process for the different functions available):
+UWAGA: ogólnie rzecz biorąc, GameMaker zrobi to wszystko za Ciebie i rzadko będziesz musiał używać wbudowanej zmiennej working_directory.
+Korzystając z tych dwóch prostych reguł, możemy teraz zobaczyć, jak działają następujące funkcje (są to przykłady ułatwiające wizualizację procesu dla różnych dostępnych funkcji):
On the Windows, macOS and Ubuntu (Linux) platforms there are two ways to save and load files from outside of the sandbox and that is either using the functions get_open_filename() and get_save_filename() (both of these functions will require that the user select an area for loading and saving and the return string can then be used in the rest of the file functions to bypass the sandbox - see the function descriptions in the language section of the manual for more details). The other way is to disable the sandbox altogether from the Game Options for the target platform (only available for Desktop targets, as discussed further up this page).
-On HTML5 it is also possible to load files from outside the sandbox from a server, however this should only be done using the function buffer_load_async() as loading synchronously has been deprecated on most browsers and will eventually be obsoleted. This means that files being loaded in this way should be saved as binary files - for example, you can save an *.ini as a string (see ini_close() for details) and then write that into a buffer which can then be saved and loaded using the async functions. Note that if you are loading images using sprite_add() then these are already dealt with asynchronously.
-You should also know that each target platform has its own save area where files and directories can be written to and read from. Below is a list of those areas for each target when sandboxed:
+Na platformach Windows, macOS i Ubuntu (Linux) istnieją dwa sposoby zapisywania i wczytywania plików spoza piaskownicy, a mianowicie za pomocą funkcji get_open_filename() oraz + get_save_filename() (obie te funkcje będą wymagały od użytkownika wybrania obszaru do wczytania i zapisania, a zwrot + string może być następnie użyty w pozostałych funkcjach plików w celu ominięcia piaskownicy - więcej szczegółów znajduje się w opisach funkcji w części językowej podręcznika). Innym sposobem jest całkowite wyłączenie piaskownicy w Opcjach gry dla platformy docelowej (dostępne tylko dla platform Desktop, o czym mowa w dalszej części strony).
+W HTML5 możliwe jest również wczytywanie plików spoza piaskownicy z witryny server, jednak należy to robić wyłącznie za pomocą funkcji buffer_load_async() jak na stronie . + ładowanie synchroniczne zostało wycofane z większości przeglądarek i w końcu przestanie być stosowane. Oznacza to, że pliki wczytywane w ten sposób powinny być zapisywane jako pliki binarne - na przykład plik *.ini można zapisać jako ciąg znaków + (zob. ini_close() szczegóły), a następnie zapisać go w pliku buffer, który może być zapisywany i ładowany przy użyciu funkcji asynchronicznych. Uwaga: + że jeśli ładujesz obrazy za pomocą sprite_add() to są one już obsługiwane asynchronicznie.
+Należy również wiedzieć, że każda platforma docelowa ma swój własny obszar zapisu, w którym można zapisywać i odczytywać pliki i katalogi. Poniżej znajduje się lista tych obszarów dla każdej platformy docelowej, gdy są one sandboxowane:
It is worth noting that the HTML5 target module has a limit on local storage (which can be between 1MB and 5MB depending on the browser) meaning that you will not be permitted to save large sprites, screenshots etc...
--
-
+
Warto zauważyć, że moduł docelowy HTML5 ma limit pamięci lokalnej (który może wynosić od 1MB do 5MB w zależności od przeglądarki), co oznacza, że nie będzie można zapisywać dużych plików sprites, zrzutów ekranu itp.
++
+
-
This page shows the all the different results that you may get when performing arithmetic operations on the different data types in GML.
-The tables all follow the same format, with the rows (left) showing the left hand side of an arithmetical operation, and the columns (right) showing the right hand side, eg:
-<result> = <LHS or row> + <RHS or column>
-Prior to GameMaker 2022.9, these tables were inverted -- the columns showed LHS and rows showed RHS. This was counter-intuitive and was changed to be the opposite.
+Na tej stronie przedstawiono różne wyniki, jakie można uzyskać, stosując arytmetykę na różnych typach danych. Wszystkie tabele mają ten sam format - kolumny przedstawiają lewą stronę operacji arytmetycznej, a wiersze prawą stronę, np:
+<LHS> + <RHS> = <result>
+
| Int32 | Int64 | Ptr | -undefined | -Array | +nieokreślone | +Tablica | ||||||||||
| Real | -Real | -Real | -String | -Real | -Real | -Error | -Error | -Error | +Real | +Real | +Błąd | +Real | +Real | +Błąd | +Błąd | +Błąd |
| Bool | -Real | -Real | -String | -Real | -Real | -Error | -Error | -Error | +Real | +Real | +Błąd | +Real | +Real | +Błąd | +Błąd | +Błąd |
| String | -Error | -Error | -String | -Error | -Error | -Error | -Error | -Error | +String | +String | +String | +String | +String | +Błąd | +Błąd | +Błąd |
| Int32 | -Real | -Real | -String | -Int32 | -Int64 | -Error | -Error | -Error | +Real | +Real | +Błąd | +Int32 | +Int64 | +Błąd | +Błąd | +Błąd |
| Int64 | -Real | -Real | -String | -Int64 | -Int64 | -Error | -Error | -Error | +Real | +Real | +Błąd | +Int64 | +Int64 | +Błąd | +Błąd | +Błąd |
| Ptr | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -||||||||
| undefined | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -||||||||
| Array | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +
| nieokreślone | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +||||||||
| Tablica | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd |
+
| Int32 | Int64 | Ptr | -undefined | -Array | +nieokreślone | +Tablica | ||||||||||
| Real | -Real | -Real | -Error | -Real | -Real | -Error | -Error | -Error | +Real | +Real | +Błąd | +Real | +Real | +Błąd | +Błąd | +Błąd |
| Bool | -Real | -Real | -Error | -Real | -Real | -Error | -Error | -Error | +Real | +Real | +Błąd | +Real | +Real | +Błąd | +Błąd | +Błąd |
| String | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd |
| Int32 | -Real | -Real | -Error | -Int32 | -Int64 | -Error | -Error | -Error | +Real | +Real | +Błąd | +Int32 | +Int64 | +Błąd | +Błąd | +Błąd |
| Int64 | -Real | -Real | -Error | -Int64 | -Int64 | -Error | -Error | -Error | +Real | +Real | +Błąd | +Int64 | +Int64 | +Błąd | +Błąd | +Błąd |
| Ptr | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -||||||||
| undefined | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -||||||||
| Array | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +
| nieokreślone | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +||||||||
| Tablica | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd |
+
| Int32 | Int64 | Ptr | -undefined | -Array | +nieokreślone | +Tablica | ||||||||||
| Real | -Real | -Real | -String | -Real | -Real | -Error | -Error | -Error | +Real | +Real | +Błąd | +Real | +Real | +Błąd | +Błąd | +Błąd |
| Bool | -Real | -Real | -Error | -Real | -Real | -Error | -Error | -Error | +Real | +Real | +Błąd | +Real | +Real | +Błąd | +Błąd | +Błąd |
| String | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | +String | +Błąd | +Błąd | +String | +Błąd | +Błąd | +Błąd | +Błąd |
| Int32 | -Real | -Real | -String | -Int32 | -Int64 | -Error | -Error | -Error | +Real | +Real | +Błąd | +Int32 | +Int64 | +Błąd | +Błąd | +Błąd |
| Int64 | -Real | -Real | -Error | -Int64 | -Int64 | -Error | -Error | -Error | +Real | +Real | +Błąd | +Int64 | +Int64 | +Błąd | +Błąd | +Błąd |
| Ptr | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -||||||||
| undefined | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -||||||||
| Array | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +
| nieokreślone | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +||||||||
| Tablica | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd |
+
| Int32 | Int64 | Ptr | -undefined | -Array | +nieokreślone | +Tablica | ||||||||||
| Real | -Real | -Real | -Error | -Real | -Real | -Error | -Error | -Error | +Real | +Real | +Błąd | +Real | +Real | +Błąd | +Błąd | +Błąd |
| Bool | -Real | -Real | -Error | -Real | -Real | -Error | -Error | -Error | +Real | +Real | +Błąd | +Real | +Real | +Błąd | +Błąd | +Błąd |
| String | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd |
| Int32 | -Real | -Real | -Error | -Int32 | -Int64 | -Error | -Error | -Error | +Real | +Real | +Błąd | +Int32 | +Int64 | +Błąd | +Błąd | +Błąd |
| Int64 | -Real | -Real | -Error | -Int64 | -Int64 | -Error | -Error | -Error | +Real | +Real | +Błąd | +Int64 | +Int64 | +Błąd | +Błąd | +Błąd |
| Ptr | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -||||||||
| undefined | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -||||||||
| Array | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +
| nieokreślone | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +||||||||
| Tablica | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd |
+
| Int32 | Int64 | Ptr | -undefined | -Array | +nieokreślone | +Tablica | ||||||||||
| Real | -Real | -Real | -Error | -Real | -Real | -Error | -Error | -Error | +Real | +Real | +Błąd | +Real | +Real | +Błąd | +Błąd | +Błąd |
| Bool | -Real | -Real | -Error | -Real | -Real | -Error | -Error | -Error | +Real | +Real | +Błąd | +Real | +Real | +Błąd | +Błąd | +Błąd |
| String | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd |
| Int32 | -Real | -Real | -Error | -Int32 | -Int64 | -Error | -Error | -Error | +Real | +Real | +Błąd | +Int32 | +Int64 | +Błąd | +Błąd | +Błąd |
| Int64 | -Real | -Real | -Error | -Int64 | -Int64 | -Error | -Error | -Error | +Real | +Real | +Błąd | +Int64 | +Int64 | +Błąd | +Błąd | +Błąd |
| Ptr | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -||||||||
| undefined | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -||||||||
| Array | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +
| nieokreślone | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +||||||||
| Tablica | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd |
+
| Int32 | Int64 | Ptr | -undefined | -Array | +nieokreślone | +Tablica | ||||||||||
| Real | -Real | -Real | -Error | -Real | -Real | -Error | -Error | -Error | +Real | +Real | +Błąd | +Real | +Real | +Błąd | +Błąd | +Błąd |
| Bool | -Real | -Real | -Error | -Real | -Real | -Error | -Error | -Error | +Real | +Real | +Błąd | +Real | +Real | +Błąd | +Błąd | +Błąd |
| String | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd |
| Int32 | -Real | -Real | -Error | -Int32 | -Int64 | -Error | -Error | -Error | +Real | +Real | +Błąd | +Int32 | +Int64 | +Błąd | +Błąd | +Błąd |
| Int64 | -Real | -Real | -Error | -Int64 | -Int64 | -Error | -Error | -Error | +Real | +Real | +Błąd | +Int64 | +Int64 | +Błąd | +Błąd | +Błąd |
| Ptr | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -||||||||
| undefined | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -||||||||
| Array | -Error | -Error | -Error | -Error | -Error | -Error | -Error | -Error | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +
| nieokreślone | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +||||||||
| Tablica | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd | +Błąd |
-
There are a few special constants that may or may not be equal to themselves, as shown in the following table:
++
Istnieje kilka stałych specjalnych, które mogą, ale nie muszą być sobie równe, jak pokazano w poniższej tabeli:
| Equality (==) | NaN | -undefined | -infinity | +nieokreślone | +nieskończoność | ||
| NaN | -false | -false | -false | +fałszywy | +fałszywy | +fałszywy | |
| undefined | -false | -true | -false | +nieokreślone | +fałszywy | +prawdziwy | +fałszywy |
| infinity | -false | -false | -true | +nieskończoność | +fałszywy | +fałszywy | +prawdziwy |
-
+
+
-
At some point when creating a game of any complexity you will probably have to deal with vectors. They are used in physics, in AI, in trigonometry and many other situations, but what is a vector? Well, to put it simply, a vector is a directed quantity. Let's start by looking at a 1 dimensional vector - which is just the same as a single number - by drawing a numbered line with an arrow starting at zero and ending at 5. This is the vector "a" which is equal to 5 and if we draw another arrow starting at the 5 and ending at the 8 we have vector "b" which is equal to 3:
-
You should realise that it doesn't matter where a vector starts, all that matters is how long it is and what direction it goes in. So vector "b" starts at 5, is 3 units long and points to the "right", making it identical to a vector starting at 0 and going to 3. Now, you can also add these vectors together, by putting the two vectors "a" and "b" end to end to get the vector "c" which is equal to 8. What about negative numbers? Well, if, in the above image, a vector that points to the "right" corresponds to a positive number, you can see that a vector pointing to the "left" would correspond to a negative number, making a one-dimensional vector nothing more than a signed (+/-) number. This explains the essential concept of a vector: only length and direction ("left" or "right" in this case) count, not position.
So, what about 2 dimensional vectors? Well, we can think of them as consisting not just of "left" and "right, but "up" and "down" too:
-
Now, those are not actually vectors yet as we still have to reduce them down using their start and end coordinates. Looking at vector "a" we can see it has a start coordinate of [2,2] and an end coordinate of [4,3] and so to get the vector from this we need to reduce it down by subtracting the end coordinates from the start coordinates like this:
Tworząc grę o dowolnej złożoności, w pewnym momencie prawdopodobnie będziesz musiał zmierzyć się z wektorami. Używa się ich w fizyce, sztucznej inteligencji, trygonometrii i wielu innych sytuacjach, ale czym jest wektor? Najprościej rzecz ujmując, wektor to wielkość skierowana. Zacznijmy od przyjrzenia się wektorowi jednowymiarowemu - który jest tym samym, co pojedyncza liczba - rysując numerowaną linię ze strzałką zaczynającą się od zera i kończącą na 5. Jest to wektor "a", który jest równy 5, a jeśli narysujemy kolejną strzałkę zaczynającą się od 5 i kończącą na 8, otrzymamy wektor "b", który jest równy 3:
+Należy sobie uświadomić, że nie ma znaczenia, gdzie wektor ma swój początek, liczy się tylko jego długość i kierunek. Tak więc wektor "b" zaczyna się od 5, ma długość 3 jednostek i jest skierowany w prawo, co czyni go identycznym z wektorem zaczynającym się od 0 i zmierzającym do 3. Teraz możesz również dodać te wektory do siebie, kładąc dwa wektory "a" i "b" końcem do końca, aby otrzymać wektor "c", który jest równy 8. A co z liczbami ujemnymi? Cóż, jeśli na powyższym rysunku wektor skierowany w prawo odpowiada liczbie dodatniej, to wektor skierowany w lewo odpowiadałby liczbie ujemnej, co sprawia, że wektor jednowymiarowy jest niczym innym jak liczbą podpisaną (+/-). Wyjaśnia to zasadniczą koncepcję wektora: liczy się tylko długość i kierunek ("w lewo" lub "w prawo" w tym przypadku), a nie położenie.
A co z wektorami dwuwymiarowymi? Cóż, możemy o nich myśleć jako o wektorach składających się nie tylko z "lewej" i "prawej", ale także z "góry" i "dołu":
+To jeszcze nie są wektory, ponieważ musimy je jeszcze zredukować, używając ich współrzędnych początkowych i końcowych. Patrząc na wektor "a", widzimy, że ma on współrzędną początkową [2,2] i końcową [4,3], a zatem aby otrzymać z niego wektor, musimy go zredukować, odejmując współrzędną końcową od współrzędnej początkowej w następujący sposób:
a = [(x2-x1), (y2-y1)] = [(4-2), (3-2)] = [2,1]
-Let's do the same for vector b now:
+Podobnie postąpmy teraz z wektorem b:
b = [(-1.2 -(-3.2)) ,(2.1 - 1.1)] = [2 ,1]
-Notice something? Those two vectors are the same! This is yet another demonstration that a vector has no position, only direction and length, and we can draw those vectors relative to each other around a local [0,0] axis:
-![2D Vectors aroun [0, 0]](../assets/Images/Scripting_Reference/Additional_Information/Vector_Image_2D.png)
This means that a 2D vector is defined by two values, an "x" and a "y" position relative to the local [0,0] axis. And what about 3D vectors? Well, they have the added dimension of "depth" to contend with and would be calculated as positions "x", "y" and "z" around a local axis something like this:
A good example of a vector used in GameMaker is the physics gravity property in the room editor. The gravity is calculated as a vector around a [0,0] position. So, if you define gravity as [x0, y10], the gravity would be down with a force of 10.
Ordinarily, vectors can be used in many situations but sometimes you want to constrain their value (like when dealing with angles) which is why we normalise them. This is essentially a mathematical trick that is used to convert a vector of length n to a vector of length 1, meaning that the vector components get normalised to be between 0 and 1. These vectors are also called unit vectors:
-
To calculate a normalised vector, we must first have the original vector components, then use them to get the length of the vector. We then divide each of the vector components by this length to get the normalised vector components which form the normalised vector in which the sum of the squares of all coordinates is equal to 1. Here's how:
First we take the coordinates of the vector and get the components:
vx = (x2 - x1); // = (7 - 1) = 6
- vy = (y2 - y1); // = (4 - 1) = 3
We then use these values to calculate the length of the vector:
-len = sqrt(sqr(vx) + sqr(vy)); // = sqrt(36 + 9) = sqrt(45) = 6.708203932499369
-Now, that gives us the exact length of the vector "a", so let's use that to normalise the two vector components vx and vy:
+Zauważyłeś coś? Te dwa wektory są takie same! To jeszcze jeden dowód na to, że wektor nie ma położenia, a jedynie kierunek i długość, i że możemy narysować te wektory względem siebie wokół lokalnej osi [0,0]:
+Oznacza to, że wektor 2D jest definiowany przez dwie wartości, pozycję "x" i "y" względem lokalnej osi [0,0]. A co z wektorami 3D? Cóż, mają one do czynienia z dodatkowym wymiarem "głębokości" i byłyby obliczane jako pozycje "x", "y" i "z" wokół lokalnej osi, mniej więcej tak jak poniżej:
Dobrym przykładem wektora używanego w programie GameMaker jest właściwość fizyki grawitacji w edytorze room. Grawitacja jest obliczana jako wektor wokół pozycji [0,0]. Jeśli więc zdefiniujesz grawitację jako [x0, y10], grawitacja będzie skierowana w dół z siłą równą 10.
Zwykle wektory można wykorzystywać w wielu sytuacjach, ale czasami chcemy ograniczyć ich wartość (np. w przypadku kątów), dlatego też dokonujemy ich normalizacji . Jest to sztuczka matematyczna służąca do przekształcenia wektora o długości n na wektor o długości 1, co oznacza, że składowe wektora są normalizowane do wartości z przedziału od 0 do 1. Wektory takie nazywane są również wektorami jednostkowymi:
+Aby obliczyć wektor znormalizowany, musimy najpierw mieć oryginalne składowe wektora, a następnie użyć ich do uzyskania długości wektora. Następnie dzielimy każdą ze składowych wektora przez tę długość, aby otrzymać znormalizowane składowe wektora, które tworzą wektor znormalizowany, w którym suma kwadratów wszystkich współrzędnych jest równa 1. Oto, jak to zrobić:
Najpierw bierzemy współrzędne wektora i otrzymujemy jego składowe:
vx = (x2 - x1) = (7 - 1) = 6
+ vy = (y2 - y1) = (4 - 1) = 3
Następnie wykorzystujemy te wartości do obliczenia długości wektora:
+len = sqr(vx2 + vy2); // = sqr(36 + 9) = sqr(45) = 6.708203932499369
+Teraz otrzymujemy dokładną długość wektora "a", więc wykorzystajmy ją do znormalizowania dwóch składowych wektora vx i vy:
vx = (vx/len); // = (6 / 6.708203932499369) = 0.8944271909999159
vy = (vy/len); // = (3 / 6.708203932499369) = 0.4472135954999579
Great! We have now normalised the components of the vector! But of what practical use is that in the context of GameMaker? Okay, let's give you a practical example...
-Say you have a game where the player has to shoot at an enemy and you need to know how much the bullet object has to move along the x and y axis each step to hit it:
-
For this you would use the player and enemy coordinates to get the vector components and the length, then you would normalise them to get a value between 0 and 1 which you would finally multiply by the speed you wish the bullet to travel at each step. These final two values you would then store and add onto the starting x and y coordinates each step. Sounds complicated? It's not, look (values have been rounded to one decimal place for simplicity):
Świetnie! Znormalizowaliśmy składowe wektora! Ale jakie praktyczne zastosowanie ma to w kontekście GameMakera? Dobrze, podajmy praktyczny przykład...
+Załóżmy, że mamy grę, w której gracz musi strzelać do przeciwnika i musimy wiedzieć, o ile razy kula object musi się przesunąć wzdłuż osi x i y w każdym kroku, aby w niego trafić:
+W tym celu należy użyć współrzędnych gracza i wroga, aby uzyskać składowe wektora i jego długość, a następnie znormalizować je, aby uzyskać wartość z przedziału od 0 do 1, którą należy pomnożyć przez prędkość, z jaką pocisk ma się poruszać w każdym kroku. Te dwie ostatnie wartości należy zapisać i dodać do początkowych współrzędnych x i y w każdym kroku. Brzmi skomplikowanie? Nie jest, spójrz (dla uproszczenia wartości zostały zaokrąglone do jednego miejsca po przecinku):
px = 100;
py = 425;
ex = 356;
@@ -47,7 +47,7 @@
So, to hit the target we need to add 3 to the bullets x coordinate and 4 to its y coordinate every step.
--
+
Aby trafić w cel, musimy co krok dodawać 3 do współrzędnej x pocisku i 4 do jego współrzędnej y.
++
+
-
Welcome to the GameMaker user manual! This document is divided into three parts with the aim of getting you introduced to the interface and basic workings of GameMaker and general programming, before going on to more advanced usage and the functions available through our proprietary programming language GML (GameMaker Language).
-To ease you into things we have created a handy Quick Start Guide, and even if you are familiar with other game creation tools we recommend that you start there to get an overview of the way that GameMaker works. You'll find GameMaker to be easy and intuitive to use and that, whatever your skill level, you will soon be making those games you've always dreamed of.
-Due to the modular nature of GameMaker there are certain things that are not included in this user manual, in particular those aspects of setting up and connecting the different devices that can be supported. For up-to-date information and troubleshooting hints and tips related to the different target platforms, please see the GameMaker Help Center.
-Returning to the manual? Here are some handy shortcuts:
- --
This section is the obligatory first stop for using GameMaker and getting to grips with the contents of the IDE and how it works. You'll find that GameMaker is intuitive and simple to use, and even if you've never used any tools like this before you shouldn't have any problems getting started and making games after reading through the Introduction and completing the Quick Start Guide (below). Once you have got to grips with the basics you can then move on to the more in-depth look at the components of GameMaker in the IDE sections below.
- +Witamy w podręczniku użytkownika GameMakera! Niniejszy dokument podzielony jest na trzy części, których celem jest zapoznanie Cię z interfejsem i podstawowymi zasadami działania GameMakera oraz ogólnego programowania, a następnie przejście do bardziej zaawansowanego użytkowania i funkcji dostępnych dzięki naszemu autorskiemu językowi programowania GML (GameMaker Language).
+Aby ułatwić Ci pracę stworzyliśmy poręczny przewodnik szybkiego startu i nawet jeśli jesteś zaznajomiony z innymi narzędziami do tworzenia gier, zalecamy, abyś zaczął od niego, aby zapoznać się ze sposobem działania GameMakera. Przekonasz się, że GameMaker jest łatwy i intuicyjny w obsłudze i że niezależnie od Twojego poziomu umiejętności, wkrótce będziesz tworzyć gry, o których zawsze marzyłeś.
+UWAGA Ze względu na modułową naturę GameMakera są pewne rzeczy, które nie są zawarte w tym podręczniku użytkownika, w szczególności te aspekty ustawiania i podłączania różnych urządzeń, które mogą być obsługiwane. Aktualne informacje i wskazówki dotyczące rozwiązywania problemów związanych z różnymi platformami docelowymi można znaleźć w Centrum Pomocy GameMakera.
++
Ta sekcja to obowiązkowy pierwszy przystanek w korzystaniu z GameMakera i zapoznaniu się z zawartością strony IDE oraz sposobem jego działania. Przekonasz się, że GameMaker jest intuicyjny i prosty w obsłudze, więc nawet jeśli nigdy wcześniej nie korzystałeś z tego typu narzędzi, nie powinieneś mieć problemów z rozpoczęciem tworzenia gier po przeczytaniu Wstępu i wypełnieniu Przewodnika Szybkiego Startu (poniżej). Kiedy już opanujesz podstawy, możesz przejść do bardziej szczegółowego spojrzenia na komponenty GameMakera w sekcjach IDE poniżej.
++
+
Setting Up And Version Information
+Konfiguracja i informacje o wersji
-
-
In this section we cover each part of the GameMaker IDE, explaining in detail what each and every window, button and menu does and how it should be used. Note that not everything covered in this section will be available to you right from the start as it will depend on the type of licence that you have for the product.
- ++
+
W tym rozdziale omówimy każdą część GameMaker IDE, wyjaśniając szczegółowo co robi każde okno, przycisk i menu oraz jak należy ich używać. Zwróć uwagę, że nie wszystko co jest opisane w tej sekcji będzie dostępne dla Ciebie od samego początku, ponieważ będzie to zależało od rodzaju licencji jaką posiadasz na produkt.
++
+
+
+
-
-
+
+
This section covers an overview to GameMaker Language, and its two programming methods: Visual and Code.
+Ten rozdział zawiera przegląd strony GameMaker Language, oraz jej dwóch metod programowania: Visual i Code.
We also have a few extra pages with information on certain aspects of programming and using the GameMaker Language:
-Mamy też kilka dodatkowych stron z informacjami na temat pewnych aspektów programowania i używania języka GameMaker:
+-
-
+
+
+
GML Visual is the visual scripting method for programming with the GameMaker Language (GML). It consists of using action blocks to construct game logic in a visual and intuitive way, and is an ideal tool for people who are learning programming, or for people that have a more visual inclination.
-The GML Visual section of the manual is split into the following sections:
+GML Visual to wizualna metoda skryptowa do programowania w języku GameMaker Language (GML). Polega ona na używaniu bloków akcji do konstruowania logiki gry w sposób wizualny i intuicyjny. Jest to idealne narzędzie dla osób uczących się programowania lub osób o skłonnościach wizualnych.
+Część podręcznika poświęcona językowi wizualnemu GML jest podzielona na następujące rozdziały:
--
+
+
diff --git a/Manual/contents/Drag_And_Drop/Drag_And_Drop_Overview/Action_Block_Functions.htm b/Manual/contents/Drag_And_Drop/Drag_And_Drop_Overview/Action_Block_Functions.htm index b9c3ace91..d59c3dc9a 100644 --- a/Manual/contents/Drag_And_Drop/Drag_And_Drop_Overview/Action_Block_Functions.htm +++ b/Manual/contents/Drag_And_Drop/Drag_And_Drop_Overview/Action_Block_Functions.htm @@ -3,10 +3,10 @@ -
One of the most important assets in the Asset Browser is the Script asset. Scripts are special assets in that they are essentially "containers" for user defined functions and are not themselves actually called by you directly in your games. All scripts are global in scope and will be run automatically by GameMaker when your game starts, so you can use them to define global variables and functions that you want to use throughout your game.
-Each GML Visual script can have one or more user-defined functions added to it, and these functions are created using the action Declare A New Function:
-
The functions you define here will be global in scope and act much like any built-in GML Visual action, i.e.: they can take different values - or none at all - called arguments (or parameters), and then perform a task, returning a value or returning nothing as required. You would then call the function in your games using the Function Call 
action, which looks like this:
To create a GML Visual script, you simply use the right mouse button 
anywhere in the Asset Browser and select Create then Script. This will create a new GML Visual script and open the editor window:
You can name the script by right clicking on it in the Asset Browser and selecting Rename (or by using a slow double left click ), but note that the script name must conform to the general rules for assets, so they must start with a letter and only contain letters, numbers or the "_" under-bar symbol. Your script will also be pre-populated with a Declare A New Function action, ready for you to fill it out, and you can add more function declarations as required (a single script can hold multiple functions, which is useful for grouping functions with similar or connected usage together).
As mentioned above, you can pass a number of arguments to a function, and it will use these to perform the task you have written it for. To understand this better, take - for example - any of the built-in actions and think about how it works... you place it in an event and supply a number of values and it will make your instance do something. User-defined functions are exactly the same, with the only difference being that you write them.
-When defining a new function, you give it a name and also define the name of any arguments it takes, if it takes any (functions can take no arguments or multiple arguments depending on what you require). If you give argument names, then these will be used in the actions that the function calls as local variables holding the function input values.
-It is also good practice to add in a comment for the action that explains what it does, following the JS Doc rules. For example, consider this function set_vec():
-
To call the script above you would simply use the Call Function action, like this:
Not only can you pass arguments into a function, but you can also ask a function to return a value (using the Return 
action), so you can use them to (for example) build calculating methods or give back an instance ID after a complex collision detection or any number of things. Please note, however, that using return ends the function, and so no actions placed after it has been used will be executed, and this means that a certain amount of thought has to go into how your functions are structured.
Below is a GML Visual function that returns a value:
-
The function above simply checks all the instances in a room to see what their object_index is and if one of them is the player object the function will return true (ending the function call) or false. You would call this function like this:
-
So, we call the function and have it create a temporary (local) variable to store the returned value (which in this case is either true or false), and then this variable is checked and an action taken.
You can also make arguments optional and define a default value, so in case they are not provided in a function call the default value will be used instead. See the action's Extended Example 2 for more information.
-When making functions for your GML Visual scripts you can use all the same actions as you would when adding actions into an object event, and you can even call functions from within functions, and in this way create more "modular" action code. Building scripts with functions in this way can save you a lot of time creating the same action sequences and can also help make your action sequences easier to read and easier to debug.
--
-
+
Jedną z najważniejszych stron assets w przeglądarce zasobów jest skrypt asset. Scripts to specjalne strony assets, ponieważ są one zasadniczo "kontenerami" dla funkcji zdefiniowanych przez użytkownika i nie są wywoływane bezpośrednio w grze. Wszystkie strony scripts mają zasięg globalny i są automatycznie uruchamiane przez stronę GameMaker po uruchomieniu gry, dlatego można ich używać do definiowania zmiennych globalnych i funkcji, które mają być używane w całej grze.
+Do każdej strony GML Visual script można dodać jedną lub więcej funkcji zdefiniowanych przez użytkownika, które są tworzone za pomocą akcji Declare A New Function (Zadeklaruj nową funkcję):
+Funkcje, które tu zdefiniujesz, będą miały zasięg globalny i będą działać podobnie jak każda wbudowana akcja GML Visual, tzn. mogą przyjmować różne wartości - lub nie przyjmować ich wcale - zwaneargumentami (lub parametrami), a następnie wykonywać zadanie, zwracając wartość lub nie zwracając nic, zależnie od potrzeb. Następnie wywołujesz funkcję w swojej grze za pomocą akcji Function Call
, która wygląda następująco:
Aby utworzyć stronę GML Visual script, wystarczy użyć prawego przycisku myszy
w dowolnym miejscu przeglądarki Asset i wybrać opcję Create , a następnie Script. Spowoduje to utworzenie nowej strony GML Visual script i otwarcie okna edytora:
Nazwę script można nadać, klikając prawym przyciskiem myszy adres
w przeglądarce Asset i wybierając opcję Zmień nazwę (lub używając powolnego podwójnego kliknięcia lewym przyciskiem myszy
), ale należy pamiętać, że nazwa script musi być zgodna z ogólnymi zasadami dla assets, a więc musi zaczynać się od litery i zawierać tylko litery, cyfry lub symbol "_" pod paskiem. Na stronie script zostanie również wstępnie wypełniona akcja Declare A New Function (Deklaracja nowej funkcji), którą możesz wypełnić, dodając kolejne deklaracje funkcji w razie potrzeby (jedna strona script może zawierać wiele funkcji, co jest przydatne do grupowania funkcji o podobnym lub powiązanym zastosowaniu).
Jak wspomniano powyżej, możesz przekazać funkcji wiele argumentów, a ona wykorzysta je do wykonania zadania, do którego została napisana. Aby to lepiej zrozumieć, weźmy na przykład dowolną wbudowaną akcję i zastanówmy się, jak ona działa... umieszczasz ją w zdarzeniu i przekazujesz pewną liczbę wartości, a ona sprawi, że twoja instancja coś zrobi. Funkcje zdefiniowane przez użytkownika działają dokładnie tak samo, a jedyną różnicą jest to, że to Ty je piszesz.
+Podczas definiowania nowej funkcji nadajesz jej nazwę oraz określasz nazwę argumentów, które przyjmuje, jeśli przyjmuje (funkcje mogą nie przyjmować żadnych argumentów lub przyjmować wiele argumentów, w zależności od tego, czego potrzebujesz). Jeśli podasz nazwy argumentów, to zostaną one użyte w akcjach wywoływanych przez funkcję jako zmienne lokalne przechowujące wartości wejściowe funkcji.
+Dobrą praktyką jest również dodanie komentarza do akcji, który wyjaśnia, co ona robi, zgodnie z zasadami JS Doc. Na przykład rozważmy tę funkcję set_vec():
+Aby wywołać powyższą stronę script, wystarczy użyć akcji Wywołaj funkcję, jak poniżej:
Do funkcji można nie tylko przekazywać argumenty, ale także prosić o zwrócenie wartości (za pomocą akcji Return
), dzięki czemu można ich używać na przykład do tworzenia metod obliczeniowych lub zwracania identyfikatora instancji po złożonym wykrywaniu kolizji, a także do wielu innych celów. Należy jednak pamiętać, że użycie return kończy działanie funkcji, a więc nie zostaną wykonane żadne akcje umieszczone po jej użyciu, co oznacza, że trzeba się dobrze zastanowić nad strukturą funkcji.
Poniżej znajduje się funkcja GML Visual, która zwraca wartość:
+
Powyższa funkcja po prostu sprawdza wszystkie instancje w room, aby zobaczyć, jaki jest ich adres object_index, i jeśli jedna z nich jest graczem object, funkcja zwróci true (kończąc wywołanie funkcji) lub false. Funkcję tę można by wywołać w następujący sposób:
+Wywołujemy więc funkcję i każemy jej utworzyć tymczasową (lokalną) zmienną do przechowywania zwróconej wartości (w tym przypadku jest to true lub false), a następnie sprawdzamy tę zmienną i podejmujemy odpowiednie działanie.
Można również uczynić argumenty opcjonalnymi i zdefiniować ich wartość domyślną, dzięki czemu w przypadku niepodania ich w wywołaniu funkcji zostanie użyta wartość domyślna. Więcej informacji na ten temat można znaleźć w przykładzie rozszerzonym akcji 2.
+Tworząc funkcje dla strony GML Visual scripts, możesz używać wszystkich tych samych akcji, co podczas dodawania akcji do zdarzenia object, a nawet możesz wywoływać funkcje z funkcji i w ten sposób tworzyć bardziej "modułowy" kod akcji. Takie budowanie scripts za pomocą funkcji może zaoszczędzić wiele czasu przy tworzeniu tej samej akcji sequences, a także ułatwić czytanie i usuwanie błędów w akcji sequences.
++
+
-
Most actions in the GML Visual libraries have an option to apply the action in different ways. This is called setting the action scope and it can be one of several things:
-
Essentially what you are telling GameMaker is the which instance should run the action. The default action scope
- is self, which means that once the object is created as an instance in the room, that instance will run the action code. However this isn't always what you want, and you may want some actions to affect other, or even
- all, instances in the room. This is where changing the action scope comes in.
The different scopes for performing actions are listed below, but it should be noted that changing the scope on an action in this way will only apply the new scope to that action and not to subsequent actions in the chain. If you want to apply - a change of action scope to multiple chained actions, then use the Apply to... action first.
-- +
Większość akcji w bibliotekach GML Visual ma możliwość zastosowania ich na różne sposoby. Nazywa się to ustawieniem zakresu akcji i może to być jedna z kilku rzeczy:
+Zasadniczo to, co mówisz GameMakerowi, to to, która instancja powinna wykonać akcję. Domyślnym zakresem akcji
+ jest self, co oznacza, że gdy object zostanie utworzona jako instancja w room, ta instancja wykona kod akcji. Jednak nie zawsze jest to zgodne z oczekiwaniami użytkownika, który może chcieć, aby niektóre akcje oddziaływały na inne, a nawet
+ lub nawet wszystkie instancje w room. W tym miejscu przydaje się zmiana zakresu akcji.
Poniżej wymieniono różne zakresy wykonywania akcji, ale należy zauważyć, że zmiana zakresu akcji w ten sposób spowoduje zastosowanie nowego zakresu tylko do tej akcji, a nie do kolejnych akcji w łańcuchu. Jeśli chcesz zastosować + zmianę zakresu akcji do wielu połączonych łańcuchowo akcji, należy najpierw użyć akcji Zastosuj do....
++
This is the default scope for an action and simply states that the action should only be called by the instance that is running the code.
-+
Jest to domyślny zakres akcji, który po prostu określa, że akcja powinna być wywoływana tylko przez instancję, która wykonuje kod.
+
The other scope has two main functions, and the value it returns will depend on where and how you use it. In the Collision Event, other will return the unique instance ID value - (a unique value that is used to distinguish individual instances of every object), so you can, for example, create a "bullet" instance and have a collision event with a "player" instance and in that use the other scope to remove hit points from the "player" object and then return to self scope to destroy the "bullet" instance.
-Outside of the collision event the other setting will behave as if it was set to noone unless it is being called from within a scoped block of actions. What this means is that if you change the - scope of a group of actions to a specific object, then while those actions are being called, the other scope will return the instance ID of the instance that initially called the action group. For example, you could run - an Apply to... action and then in the next code block set the scope to other to perform an action on the instance running the whole event block, and not the - instance that is being scoped in the apply to code blocks. The image below gives an example:
-
In the image, we are checking for a mouse press in the instance, and if one is detected we change scope using the Apply To... action. The next two action blocks are now being called from the "obj_Player" instance (if there is more than one then it will run for all of them) and so the object will change its sprite and then create an object at the other position,
- ie: the position of the object that is running the event and detected the mouse press.
+
Zakres other ma dwie główne funkcje, a wartość, którą zwraca, zależy od tego, gdzie i jak jej używasz. W zdarzeniu kolizji other zwróci unikatową wartość identyfikatora instancji + (unikatowa wartość, która jest używana do rozróżniania poszczególnych instancji każdego object), więc można na przykład utworzyć instancję "pocisku" i wywołać zdarzenie kolizji z instancją "gracza", a następnie użyć zakresu other do usunięcia punktów trafienia z instancji "gracza" object i powrócić do zakresu self, aby zniszczyć instancję "pocisku".
+Poza zdarzeniem kolizji ustawienie other będzie się zachowywało tak, jakby było ustawione na noone, chyba że zostanie wywołane z bloku akcji o określonym zakresie. Oznacza to, że jeśli zmienisz zakres + zakres grupy akcji na określony object, to podczas wywoływania tych akcji zakres other będzie zwracał identyfikator instancji, która pierwotnie wywołała grupę akcji. Na przykład można uruchomić + akcję Apply to..., a następnie w następnym bloku kodu ustawić zakres na other, aby wykonać akcję na instancji uruchamiającej cały blok zdarzeń, a nie na instancji, która jest przypisana w bloku zdarzenia. + a nie instancji, do której odnosi się blok kodu apply to. Poniższa ilustracja przedstawia przykład:
+Na obrazku sprawdzamy, czy w instancji jest naciśnięcie myszy, a jeśli takowe zostanie wykryte, zmieniamy zakres za pomocą akcji Apply To.... Kolejne dwa bloki akcji są teraz wywoływane z instancji "obj_Player" (jeśli jest ich więcej niż jeden, to będą uruchamiane dla wszystkich), więc object zmieni swoją sprite, a następnie utworzy object w innej pozycji,
+ tzn. na pozycji object, która obsługuje zdarzenie i wykryła naciśnięcie myszy.
When you scope an action for all, you are telling GameMaker to run that block for every single active instance within the current room. For example creating a Destroy Object Instance action - and setting its scope to all will cause every instance in the room to disappear, no matter what object they have been created from.
-+
Gdy określasz akcję dla wszystkich, mówisz GameMakerowi, by uruchomił ten blok dla każdej pojedynczej aktywnej instancji w bieżącym pomieszczeniu. Na przykład utworzenie akcji Destroy Object Instance + i ustawienie jej zakresu na all spowoduje, że każda instancja w room zniknie, bez względu na to, z jakiej strony object została utworzona.
+
An action can also be given an object as it's scope. What this means is that all instances of the given object will run that action at the same time it is called. So if you have 100 enemy instances in the room, for example, and - you want to set them all to point towards a specific point. You'd call the Set Point Direction and set the action scope to the object "obj_Enemy" and when it - is called, all instances of that object will change direction.
-+
Akcji można również nadać obiekt jako jej zakres. Oznacza to, że wszystkie instancje danego obiektu object wykonają tę akcję w tym samym momencie, w którym zostanie ona wywołana. Na przykład, jeśli masz 100 instancji wroga w room i chcesz + chcesz je wszystkie ustawić tak, by wskazywały na określony punkt. Wywołasz polecenie Ustaw kierunek punktu i ustawisz zakres akcji na object "obj_Enemy", a gdy zostanie ono + zostanie wywołana, wszystkie instancje tego object zmienią kierunek.
+
The Expression input field is for you to input the ID of a specific instance that you want the action to work on. It can be the unique ID value assigned to an instance from the Room Editor or it can be the ID of an instance that you've stored - in a variable (where the variable would be the input value) or it can even be an expression using code, as shown in the image below:
-
In this case, an instance calls the Set Sprite from
- the instance created by the code given for the Expression. Note that in this case, the instance being created will run its Create Event first before the action is applied to it.
+
Pole Expression służy do wprowadzania identyfikatora konkretnej instancji, na której ma działać akcja. Może to być unikalna wartość ID przypisana do instancji w edytorze Room, może to być ID instancji, którą zapisałeś + w zmiennej (gdzie zmienna byłaby wartością wejściową) lub może to być nawet wyrażenie zawierające kod, jak pokazano na poniższym obrazku:
+W tym przypadku instancja wywołuje Set Sprite z
+ instancji utworzonej za pomocą kodu podanego dla wyrażenia. Zauważ, że w tym przypadku tworzona instancja najpierw uruchomi zdarzenie Create Event, zanim zostanie do niej zastosowana akcja.
-
-
+
+
+
-
Another feature of GML Visual is that you can convert it into GML Code, and in this way see what exactly is going on behind the scenes when you use actions. Before actually changing the actions into code however, you can first Preview them by using the right mouse button menu option Live Preview:
Which will open a new window:
As you add, change or remove GML Visual actions, the GML Live Preview will update to show you the actual code that is being created "behind the scenes". The code in the live preview cannot be edited directly, but you can select sections and copy them for pasting into GML scripts or Code Actions (for example).
If you decide that you want to convert the GML Visual into code after seeing the preview, then this can be done again by clicking the right mouse button in any event workspace with actions and selecting Convert To GML Code.
The first time you do this you will be given a warning message saying that this is a one way conversion, since you can convert actions to code, but you cannot convert them back to individual actions again later. Clicking "okay" here will perform the conversion for you.
The resulting code will use {} to delimit individual actions, and you can clearly see what actions relate to which functions or variable declarations within the code. If the GML Visual is more complex then the code will be too, but the same general rules apply and code will be structures sequentially exactly the same as you have written the GML Visual. Note that sometimes the code will have extra local (temporary) variables added in to store certain values that will be used, for example this:
Will become this code:
-
Here the code first of all creates a local (temporary) variable and sets it to false, then it checks if the instance exists and sets the local variable to the return of the function call. The local variable is then checked to see if it is true or false and if it is true the rest of the code is run.
-When learning to program using GML Visual, this can be an important tool in moving on to using GML at a later stage, but it's by no means obligatory and you can still make great games using GML Visual! It's also worth noting that while the conversion process is one way, after converting actions to code, you can go back to using GML Visual again by using the right click menu in the code editor and selecting "Convert To GML Visual". This will place the previously created code within an Execute Code action and you can then continue to use GML Visual as before:
-
+
Kolejną cechą strony GML Visual jest to, że można ją przekształcić w GML Code i w ten sposób zobaczyć, co dokładnie dzieje się za kulisami podczas używania akcji. Jednak przed faktycznym przekształceniem akcji w kod można najpierw wyświetlić ich podgląd , używając prawego przycisku myszy i opcji menu Podgląd na żywo:
Spowoduje to otwarcie nowego okna:
Podczas dodawania, zmieniania lub usuwania akcji wizualnych GML, podgląd na żywo GML będzie aktualizowany, aby pokazać rzeczywisty kod, który jest tworzony "za kulisami". Kodu w podglądzie na żywo nie można bezpośrednio edytować, ale można zaznaczać fragmenty i kopiować je w celu wklejenia np. do strony GML scripts lub Akcje kodowe.
Jeśli po obejrzeniu podglądu zdecydujesz, że chcesz przekonwertować stronę GML Visual na kod, możesz to zrobić ponownie, klikając prawym przyciskiem myszy w dowolnym zdarzeniu workspace z działaniami i wybierając opcję Convert To GML Code.
Za pierwszym razem zostanie wyświetlone ostrzeżenie, że jest to konwersja jednokierunkowa, ponieważ można konwertować akcje na kod, ale nie można ich później ponownie przekształcić na pojedyncze akcje. Kliknięcie przycisku "OK" spowoduje, że konwersja zostanie wykonana za Ciebie.
Kod wynikowy będzie wykorzystywał stronę {} do oddzielania poszczególnych czynności, a użytkownik może wyraźnie zobaczyć, które czynności odnoszą się do których funkcji lub deklaracji zmiennych w kodzie. Jeśli strona GML Visual jest bardziej złożona, to i kod będzie bardziej złożony, ale obowiązują te same ogólne zasady i kod będzie sekwencyjnie budowany dokładnie tak samo, jak w przypadku strony GML Visual. Zwróć uwagę, że czasami w kodzie zostaną dodane dodatkowe zmienne lokalne (tymczasowe) do przechowywania pewnych wartości, które będą używane, na przykład to:
Stanie się tym kodem:
+
W tym przypadku kod najpierw tworzy zmienną lokalną (tymczasową) i ustawia ją na false, następnie sprawdza, czy instancja istnieje i ustawia zmienną lokalną na wartość zwracaną przez wywołanie funkcji. Następnie sprawdzane jest, czy zmienna lokalna ma wartość true czy false, a jeśli ma wartość true, uruchamiana jest reszta kodu.
+Podczas nauki programowania przy użyciu GML Visual może to być ważne narzędzie do przejścia na GML na późniejszym etapie, ale nie jest to w żadnym wypadku obowiązkowe i nadal można tworzyć świetne gry przy użyciu GML Visual! Warto też zauważyć, że choć proces konwersji jest jednokierunkowy, po przekształceniu akcji w kod można wrócić do korzystania z GML Visual, klikając prawym przyciskiem myszy w edytorze kodu i wybierając opcję "Convert To GML Visual". Spowoduje to umieszczenie wcześniej utworzonego kodu w akcji Execute Code (Wykonaj kod), po czym można dalej używać GML Visual jak poprzednio:
+
-
To add behaviours to objects you can construct your code using Actions from the different libraries available to you from the Action Toolbox. To start with you'll need to make a new GML Visual project and then make a new object (you can assign a sprite to the object too if required). In your new object you can start to add events, and in the events add your GML Visual code actions.
-
Note that when you add a new event, a "code" window is opened with a tab for the given event (see the image above), and you can now drag any action you wish from the Toolbox on the right into the Action Block pane of the code window. Now, while it's true that you can add any action, that doesn't mean that they will all work or that the project will compile with them. Some actions require at least one variable to work, while others - like the Draw actions - will only work if used in a specific event. How do you know which ones to use? Well, generally, it's simply a question of using logic... if an action requires a variable and we haven't defined one yet, then we shouldn't be using it until we've added an action to create the variable.
When you drag an action from the Toolbox into the main Action Block workspace, it will expand to show you the available arguments (parameters) that you can fill in and change to set the behaviour. In the image below, we have dragged an Assign Variable action from the Toolbox Common library into the action block workspace:
-
You can see that the new action is also shown on the left of the code window in a shorthand form. This list of actions, called the action Overview, can be clicked on to quickly navigate to that action for editing. You can continue to add actions to the event should you need to, with each new action being "chained" to the previous one to show the flow of the GML Visual code you are constructing. Note that the area where you can drop further actions is highlighted for you underneath the initial action, and, depending on the action you are using, different areas will highlight to show where in the chain you can add it:
As you add actions to the workspace, they will be "chained" to the actions above so you can see how the GML Visual code flows, with one action leading to another, and the overview pane shows them in shorthand form and in order of execution:
Some actions will place code in a separate chain away from the main flow - things like If Variable will create a sub-chain of actions that should occur if the correct conditions are met before continuing on with the main chain:
Note that when using actions that can have a side chain block like this, the action will have two areas highlighted for dropping further actions:
Aby dodać zachowania do strony objects, możesz skonstruować swój kod za pomocą akcji ( Actions ) z różnych bibliotek dostępnych w oknie narzędziowym Action Toolbox. Na początek musisz utworzyć nowy projekt GML Visual, a następnie nowy obiekt (w razie potrzeby możesz też przypisać sprite 'a do object ). W nowym projekcie object możesz zacząć dodawać eventsa w zdarzeniach dodaj swoje akcje z kodu GML Visual.
+Zauważ, że po dodaniu nowego zdarzenia otwierane jest okno "kodu" z zakładką dla danego zdarzenia (patrz ilustracja powyżej), a teraz możesz przeciągnąć dowolną akcję z Przybornika po prawej stronie do okienka Bloku akcji w oknie kodu. To prawda, że możesz dodać dowolną akcję, ale nie oznacza to, że wszystkie one będą działać i że projekt się z nimi skompiluje. Niektóre akcje wymagają do działania co najmniej jednej zmiennej, a inne - jak na przykład akcja Rysuj - będą działać tylko wtedy, gdy zostaną użyte w określonym zdarzeniu. Skąd wiadomo, których z nich użyć? Cóż, na ogół jest to po prostu kwestia logiki... jeśli akcja wymaga zmiennej, a my jeszcze jej nie zdefiniowaliśmy, to nie powinniśmy jej używać, dopóki nie dodamy akcji tworzącej tę zmienną.
Po przeciągnięciu akcji z Przybornika na główną stronę bloku akcji workspace, zostanie ona rozwinięta, aby pokazać dostępneargumenty (parametry), które można wypełnić i zmienić, aby ustawić zachowanie. Na poniższym rysunku przeciągnęliśmy akcję Przydziel zmienną z biblioteki Toolbox Common do obszaru roboczego bloku akcji:
+Można zauważyć, że nowa akcja jest również wyświetlana po lewej stronie okna kodu w formie skróconej. Ta lista akcji, zwana Przeglądem akcji, może być kliknięta, aby szybko przejść do tej akcji w celu jej edycji. W razie potrzeby można kontynuować dodawanie akcji do zdarzenia, przy czym każda nowa akcja jest "połączona" z poprzednią, aby pokazać przepływ tworzonego kodu GML Visual. Zauważ, że obszar, w którym można umieszczać kolejne akcje, jest podświetlony pod akcją początkową, a w zależności od używanej akcji różne obszary będą podświetlone, aby pokazać, w którym miejscu łańcucha można ją dodać:
Po dodaniu działań do witryny workspace zostaną one "połączone" z działaniami znajdującymi się powyżej, dzięki czemu można zobaczyć, jak przepływa kod wizualny GML, w którym jedno działanie prowadzi do drugiego, a w okienku przeglądu są one wyświetlane w skróconej formie i w kolejności wykonywania:
Niektóre akcje umieszczają kod w osobnym łańcuchu, z dala od głównego przepływu - takie rzeczy jak Jeśli zmienna utworzy podłańcuch akcji, które powinny wystąpić, jeśli zostaną spełnione odpowiednie warunki, przed kontynuowaniem głównego łańcucha:
Należy pamiętać, że podczas korzystania z akcji, które mogą mieć blok łańcucha bocznego, jak w tym przypadku, akcja będzie miała podświetlone dwa obszary umożliwiające upuszczanie kolejnych akcji:
You can change the position of actions within the chain by simply clicking and dragging them into the new position that you require, and if you do a click and hold for a second then move the mouse, you can move the action within the workspace while maintaining its place within the action block chain.
It is also possible to add comments to GML Visual actions, so you can leave notes beside different blocks to explain what they do (which is especially useful when working in a team):
-
You can find out more about this feature from the page on the Right Mouse Button Menu.
That's the basics of using the GML Visual code editor, but there are further important details explained in the sections below:
-- +
Pozycję akcji w łańcuchu można zmienić, klikając stronę
i przeciągając ją w nowe miejsce, a jeśli klikniesz stronę
i przytrzymasz przez sekundę, a następnie poruszysz myszą, możesz przesunąć akcję w obrębie strony workspace, zachowując jej miejsce w łańcuchu bloków akcji.
Istnieje również możliwość dodawania komentarzy do strony GML Visual actions, dzięki czemu obok różnych bloków można umieszczać notatki wyjaśniające ich działanie (jest to szczególnie przydatne podczas pracy w zespole):
+Więcej informacji na temat tej funkcji można znaleźć na stronie poświęconej menu prawego przycisku myszy.
Tak wyglądają podstawy korzystania z edytora kodu GML Visual, ale w poniższych sekcjach wyjaśniono jeszcze inne ważne szczegóły:
++
It is important to note that many actions offer a "target" variable, which can be flagged as "Temporary", for example:
-
What this means is that you can supply a variable which is the target to hold the value returned by the action. In the example action above, the action will return the volume of the audio resource that you select, so you supply a target variable to hold this value so you can reference it later.
Now, this target variable will need to have been declared previously either using Assign Variable (which creates an Instance Variable) or Declare Temporary Variable (which creates a Local Temporary Variable) If you check the "Temp" option, then you can simply add a variable name and the action will create that variable and set it to hold the return value for you (creating a temporary local variable). Any actions used after this can now access the value in the temporary variable, but only within the same Event or Script. Temporary variables are only available within the scope that they were created. For more in depth information on variables and variable scope, please see here.
-+
Należy zauważyć, że wiele działań oferuje zmienną "cel", która może być oznaczona na przykład jako "Tymczasowa":
+Oznacza to, że można podać zmienną docelową, która będzie przechowywała wartość zwracaną przez akcję. W powyższym przykładzie akcja zwróci głośność wybranego przez użytkownika zasobu audio, dlatego podajemy zmienną docelową, która będzie przechowywać tę wartość, aby można się było do niej później odwołać.
Jeśli zaznaczysz opcję "Temp", możesz po prostu dodać nazwę zmiennej, a akcja utworzy tę zmienną i ustawi ją tak, aby przechowywała wartość zwracaną przez użytkownika (tworząc tymczasową zmienną lokalną). Wszystkie akcje użyte po tej operacji mogą teraz uzyskać dostęp do wartości zmiennej tymczasowej, ale tylko w ramach tego samego zdarzenia lub skryptu. Zmienne tymczasowe są dostępne tylko w zakresie, w którym zostały utworzone. Więcej szczegółowych informacji na temat zmiennych i zakresu zmiennych można znaleźć tutaj.
+
Not only variables have scopes (see the Target Variables section, above), actions can have different scopes too. In fact, almost all actions can be given a different scope to work in, set from the drop down window opened in the action itself as shown here:
-You can also set the scope for all further actions using the special action Apply to. For more information on this feature of the GML Visual actions, please see here:
Nie tylko zmienne mają zakresy (patrz sekcja Zmienne docelowe , powyżej), również akcje mogą mieć różne zakresy. W rzeczywistości prawie wszystkim akcjom można przypisać różne zakresy działania, ustawiane w oknie rozwijanym w samej akcji, jak pokazano tutaj:
+Za pomocą akcji specjalnej Zastosuj do można także określić zakres wszystkich dalszych działań. Więcej informacji na temat tej funkcji akcji wizualnych GML można znaleźć tutaj:
+
When working with GML Visual you will have to add variables and expressions into the different input fields of the actions. However, as you do this you will often get the Auto Complete window popping up to help you:
-
This pop up window will list all the built in GML (GameMaker Language) variables, constants and functions, as well as any resources that contain the initial letters of what you were typing. It can be used to quickly find the resource or variable that you are wanting for the action without having to type it all in yourself. For example, if all your rooms are prefixed "rm_" then typing that and waiting a moment will show the auto complete window with all the assets beginning with "rm_". Note that all the built in variables that are shown in the auto complete window can be used anywhere where a variable or expression is expected in an action, as can most GML functions.
+
Podczas pracy z GML Visual będziesz musiał dodawać zmienne i wyrażenia do różnych pól wprowadzania działań. W trakcie tej czynności często pojawia się okno Autouzupełniania, które pomaga w tym zadaniu:
+W tym oknie pojawi się lista wszystkich wbudowanych w GML (GameMaker Language) zmiennych, stałych i funkcji, a także wszelkich zasobów, które zawierają początkowe litery wpisywanego tekstu. Można go użyć do szybkiego znalezienia zasobu lub zmiennej, która jest potrzebna do wykonania danej czynności, bez konieczności wpisywania jej samodzielnie. Na przykład, jeśli wszystkie strony rooms są poprzedzone "rm_", to wpisanie tej litery i odczekanie chwili spowoduje wyświetlenie okna autouzupełniania ze wszystkimi stronami assets zaczynającymi się od "rm_". Należy pamiętać, że wszystkie wbudowane zmienne, które są widoczne w oknie autouzupełniania, mogą być używane wszędzie tam, gdzie w działaniu jest oczekiwana zmienna lub wyrażenie, podobnie jak większość funkcji GML.
Sometimes when using an action you will see a small plus icon 
to the side. This means that you can expand the action to perform extra tasks or take further arguments. For example, if you look at the Declare Temporary Variables action, you can see that it has this icon:
When you click the icon, the action will expand and permit you to declare more variables, making it easier and faster to define multiple variables at the same time.
The icon can also be used for those actions that require optional arguments, like the Choose action, which permits you to add various different values to be returned:
Czasami podczas używania akcji można zobaczyć małą ikonę plusa z boku. Oznacza to, że można ją rozwinąć, aby wykonać dodatkowe zadania lub przyjąć dalsze argumenty. Na przykład, jeśli spojrzysz na akcję Deklarowanie zmiennych tymczasowych, zobaczysz, że ma ona taką ikonę:
Po kliknięciu ikony akcja zostanie rozwinięta i umożliwi zadeklarowanie większej liczby zmiennych, co ułatwi i przyspieszy jednoczesne definiowanie wielu zmiennych.
Ikona ta może być także używana w akcjach wymagających opcjonalnych argumentów, takich jak akcja Wybierz, która umożliwia dodawanie różnych wartości zwracanych przez użytkownika:
-
-
+
+
+
-
GML Visual is a visual scripting tool that can be used to create your games without actually typing any code. That's not to say that you aren't programming code when you use GML Visual, as you are, only that your code is created and presented in a visual way using "blocks" of actions rather than text. Actions are simple expressions or statements that can be "chained" together to have an instance of an object do something when placed in a room. For example, you could have an action in a Create Event to move an instance in a random direction, and another action in a Collision Event to make it bounce off the things it collides with (for more information on the different events available and how they work together see the section on Object Events).
-
The image above shows a typical object open on a workspace to be edited. It has an "Event" window and a "Code" window chained to it, and in the code window you can see where we have constructed our GML Visual. Let's look a bit closer at this window and see what options are available to us:
Below you can find more information on each of the sections shown:
GML Visual to wizualne narzędzie skryptowe, którego można używać do tworzenia gier bez wpisywania kodu. Nie oznacza to, że używając GML Visual, nie programujesz kodu, bo tak jest, ale kod jest tworzony i prezentowany w sposób wizualny, przy użyciu "bloków" akcji , a nie tekstu. Akcje to proste wyrażenialubinstrukcje, które można "łączyć" ze sobą, aby instancja obiektu object wykonała jakąś czynność po umieszczeniu jej na stronie room. Na przykład w zdarzeniu Utwórz można umieścić akcję, która przesuwa instancję w losowym kierunku, a w zdarzeniu Z derzenie inną akcję, która sprawia, że instancja odbija się od przedmiotów, z którymi się zderzy (więcej informacji o różnych dostępnych zdarzeniach i ich działaniu znajdziesz w rozdziale Zdarzenia obiektów).
+Powyższy obrazek przedstawia typową stronę object otwartą na obszarze roboczym, który ma być edytowany. Ma ono okno "Event" i połączone z nim okno "Code", a w oknie kodu widać, gdzie skonstruowaliśmy nasz GML Visual. Przyjrzyjmy się nieco bliżej temu oknu i zobaczmy, jakie opcje są dla nas dostępne:
Poniżej znajduje się więcej informacji na temat każdej z przedstawionych sekcji:
When you add an Event to your object, a new tab is opened in the code window to display the contents of that event. You can add multiple events and have multiple tabs open at the same time, switching between them and editing them as you wish. You can also close the tabs at any time to reduce clutter (selecting the event in the object again will re-open them), and you can click and drag the tab out of the window into its own code window, in which case closing the object or the code window will not close the new window. Tabs can be dragged left or right to be re-ordered too.
+
Po dodaniu zdarzenia do witryny object w oknie kodu jest otwierana nowa karta, na której jest wyświetlana zawartość tego zdarzenia. Można dodać wiele wydarzeń i mieć otwartych wiele kart jednocześnie, przełączając się między nimi i edytując je według własnego uznania. Karty można też w każdej chwili zamknąć, aby zmniejszyć bałagan (ponowne wybranie zdarzenia na stronie object spowoduje ich ponowne otwarcie), można też kliknąć przycisk i przeciągnąć kartę z okna do własnego okna kodu. W takim przypadku zamknięcie strony object lub okna kodu nie spowoduje zamknięcia nowego okna. Karty można również przeciągać w lewo lub w prawo, aby zmienić ich kolejność.
As you add action blocks to your event, they will appear in "shorthand" form as a plain English overview of what's going on. The overview order is the order in which each of the action blocks will be run for that event, and you can click on any item in the list to have the action block view zoom to that position for editing.
-+
W miarę dodawania bloków akcji do wydarzenia będą one wyświetlane w formie skróconej, jako przegląd tego, co się dzieje. Kolejność przeglądania to kolejność, w jakiej będą uruchamiane poszczególne bloki akcji dla danego zdarzenia. Możesz kliknąć dowolny element na liście, aby widok bloku akcji został powiększony do tej pozycji w celu edycji.
+
This workspace area is where you drag Actions from the Toolbox to create your GML Visual code. Click on an action and drag it into this area to add it to the list of actions and edit it. Most actions have various arguments (parameters) that you can set, and most will also take keywords, instance variables, or even GML functions - for example, you can call the Set Direction action and use the GML function random(val) to set a random direction.
As you add action blocks to your code, they will be visually "chained" together to indicate the order in which different actions will occur, although how this chain is created will depend on the initial block that has been used. For example, an If Variable block will have two chains - one to the blocks that are to be called if the condition being checked is true and then the next block after that. For more information on constructing action blocks into code, see the sections linked below.
-While in the Action Block workspace, you can press and hold the middle mouse button 
to pan around and the mouse wheel to scroll the action list up or down. If you hold 
while moving the mouse wheel, then the view will scroll left/right, and if you hold down 
/ 
and move the mouse wheel then the view will zoom in and out, permitting you to see more of the workspace with the actions. You can click on any action from the action list on the left to focus on that action, resetting the zoom and position. Also note that you can resize the action blocks by moving the mouse towards the edges of the block and then - when the cursor changes - dragging in the direction you require.
You can also right click anywhere in the GML Visual workspace to bring up the RMB Menu, which is explained in detail here.
+
W tym obszarze workspace można przeciągać Akcje z Przybornika , aby tworzyć kod wizualny GML. Kliknij przycisk na akcji i przeciągnij ją do tego obszaru, aby dodać ją do listy akcji i edytować. Większość akcji ma różneargumenty (parametry), które można ustawić, a większość z nich przyjmuje także słowa kluczowe, zmienne instancji, a nawet funkcje GML - na przykład można wywołać akcję Ustaw kierunek i użyć funkcji GML random(val) aby ustawić losowy kierunek.
Podczas dodawania bloków akcji do kodu będą one wizualnie "łączone w łańcuchy", aby wskazać kolejność, w jakiej będą wykonywane różne akcje, chociaż sposób tworzenia tego łańcucha będzie zależał od użytego bloku początkowego. Na przykład blok If Variable będzie miał dwa łańcuchy - jeden do bloków, które mają być wywołane, jeśli sprawdzany warunek ma wartość true, a następnie do następnego bloku po nim. Więcej informacji na temat konstruowania bloków akcji w kodzie można znaleźć w sekcjach, do których prowadzą poniższe odnośniki.
+W bloku akcji workspace można nacisnąć i przytrzymać środkowy przycisk myszy , aby przesuwać widok, a kółko myszy
, aby przewijać listę akcji w górę lub w dół. Jeśli przytrzymasz przycisk
i jednocześnie będziesz poruszać kółkiem myszy, widok będzie przewijany w lewo/prawo, a jeśli przytrzymasz przyciski
/
i będziesz poruszać kółkiem myszy, widok zostanie powiększony lub pomniejszony, umożliwiając zobaczenie większej części strony workspace z działaniami. Możesz kliknąć
na dowolnej akcji z listy akcji po lewej stronie, aby skupić się na tej akcji, resetując zoom i pozycję. Należy także pamiętać, że można zmieniać rozmiar bloków działań, przesuwając mysz w kierunku krawędzi bloku, a następnie - gdy kursor się zmieni - przeciągając w wybranym kierunku.
Można także kliknąć prawym przyciskiem myszy stronę w dowolnym miejscu witryny GML Visual workspace, aby wyświetlić Menu RMB, którego działanie szczegółowo opisano tutaj.
The toolbox is where all the GML Visual actions are stored, with different sections holding collections (libraries) of actions that are similar or related. Each collection of actions is related to a specific theme or common purpose and you simply click and drag the required action from the toolbox into the action block workspace to add it to the current event. To make things simpler - as there are a lot of actions - you can use the "Search" bar at the top to search for a specific action or to filter the visible actions (type "draw" for example to get all the drawing actions), and you can also click and drag icons from any library into your Favourites folder to keep commonly used actions together. This is particularly useful if there are certain things you'll be doing again and again. The favourites folder can be cleared by clicking the small "bin" icon.
For a complete list of the actions available, as well as what arguments they take and how they can be chained, please see the GML Visual Reference section.
-You can use the right mouse button on any action in the toolbox to open the following menu:
Here you have the following options:
+W przyborniku przechowywane są wszystkie akcje GML Visual, a w różnych sekcjach znajdują się kolekcje (biblioteki) akcji, które są podobne lub powiązane. Każda kolekcja akcji jest związana z określonym tematem lub wspólnym celem. Wystarczy kliknąć przycisk i przeciągnąć żądaną akcję z przybornika do bloku akcji workspace, aby dodać ją do bieżącego zdarzenia. Aby ułatwić sobie pracę - ponieważ działań jest bardzo dużo - można użyć paska "Szukaj" u góry, aby wyszukać określone działanie lub przefiltrować widoczne działania (na przykład wpisać "rysuj", aby uzyskać wszystkie działania związane z rysowaniem). Można także kliknąć przycisk
i przeciągnąć ikony z dowolnej biblioteki do folderu Ulubione, aby przechowywać często używane działania razem. Jest to szczególnie przydatne, jeśli pewne czynności będą wykonywane wielokrotnie. Folder Ulubione można wyczyścić, klikając małą ikonę "kosz".
Pełną listę dostępnych akcji, a także argumenty, jakie przyjmują, oraz sposoby łączenia ich w łańcuchy można znaleźć w sekcji GML Visual Reference.
+Za pomocą prawego przycisku myszy na dowolnym działaniu w przyborniku można otworzyć następujące menu:
W tym miejscu dostępne są następujące opcje:
+
-
The following pages go into a bit more depth about how to construct action block code, as well as how to set the scope of the actions to affect different things within your project and other important details:
++
Na następnych stronach omówiono nieco dokładniej sposób konstruowania kodu bloku akcji, a także to, jak ustawić zakres akcji, aby wpływały na różne rzeczy w projekcie, oraz inne ważne szczegóły:
-
-
+
+
+
-
When working on your GML Visual code, you can click the right mouse button on the action, on the workspace, or on the text in the shortlist on the left
- to open up the Right Mouse button menu:
This menu has the following options:
Podczas pracy nad kodem GML Visual można kliknąć prawym przyciskiem myszy na akcji, na stronie workspace, lub na tekście na liście skróconej po lewej stronie
+ aby otworzyć menu Prawy przycisk myszy:
W tym menu dostępne są następujące opcje:
+ outside of the actions and drag, or use / + on individual actions,
- to select more than one and apply the command to all of them.Once you have added the comment, you can click on it and drag it to position it vertically and horizontally - although
- only to the right of the parent node - and collapsing the GML Visual node will also collapse the comment and show a summary of its contents (in which case it cannot be repositioned). If the comment is no longer required, then you can either delete all
- the text in the comment, or use the Remove Comment option from the menu. Note that when you copy a node, the comment will be copied along with it, and if you convert the node from GML Visual to GML, then the comment will be preserved
- and added to the GML that is created, as illustrated in the image below:
As mentioned above, a comment can only be applied to a single node, but you can expand it to cover multiple
- nodes by simply adding in line breaks to extend it - although this may require you to re-position the comment to prevent overlaps with subsequent nodes:
Once a comment has been added, you can select the "Comment" option
- again from the RMB menu or you can double click on it to enable editing.
You can see that the actions "If Score" and "Go To Next Room" have been disabled -
- they have been grayed out, visually - and so they will be skipped when the game is tested or compiled.
As you can see, the actions take up much less space, and you can still see what they do from the short
- description given to the right. You can select the "Expand All" option to undo this for every node in the workspace.
The menu items available here are:
+ 
The following two options are only available when the RMB menu is opened on a GML Visual node:
+Poniższe dwie opcje są dostępne tylko wtedy, gdy menu RMB jest otwarte na węźle GML Visual:
on the node.-
-
+
+
+
-
GameMaker has a complete audio engine that is based on the *.ogg, *.mp3 and *.wav sound formats. Sounds of these types added to the IDE can then be used in your game using the basic audio actions shown below. For things more complex than basic sound effects or playing a single piece of music you can refer to the advanced audio functions dedicated to streaming audio, positioning audio - to give 3D sound - and grouping audio.
The Audio library has the following actions:
+GameMaker posiada kompletny silnik dźwiękowy oparty na formatach *.ogg,
+ *.mp3 oraz *.wav. Dźwięki tych typów dodane do IDE można następnie wykorzystać w grze za pomocą podstawowych akcji dźwiękowych pokazanych poniżej. W przypadku bardziej złożonych zadań niż podstawowe efekty dźwiękowe lub odtwarzanie pojedynczych
+ lub odtwarzanie pojedynczego utworu muzycznego, można skorzystać z zaawansowanych funkcji audio poświęconych przesyłaniu strumieniowemu dźwięku, pozycjonowaniu dźwięku - w celu uzyskania dźwięku 3D - oraz grupowaniu dźwięku.
WAŻNE! Używając dźwięku w celu HTML5, należy pamiętać, że nie wszystkie przeglądarki obsługują technologię Web Audio i w związku z tym po uruchomieniu mogą nie odtwarzać dźwięku w projekcie. Ogólne pojęcie o obsłudze Web Audio można uzyskać z następujących stron + łącze: Czy mogę używać Web Audio?
+Biblioteka Audio ma następujące funkcje:
 |
- Play Audio | + |
+ Odtwarzanie dźwięku |
 |
- Stop Audio | + |
+ Zatrzymaj dźwięk |
 |
- Stop All Audio | + |
+ Zatrzymaj wszystkie dźwięki |
 |
- Pause Audio | + |
+ Wstrzymaj dźwięk |
 |
- Pause All Audio | + |
+ Wstrzymaj wszystkie dźwięki |
 |
+ |
Resume Audio | |
 |
- Resume All Audio | + |
+ Wznów wszystkie dźwięki |
 |
- Set Audio Position | + |
+ Ustaw pozycję dźwięku |
 |
- Get Audio Length | + |
+ Uzyskaj długość dźwięku |
 |
- Set Audio Pitch | + |
+ Ustawianie wysokości dźwięku |
 |
- Get Audio Pitch | + |
+ Pobierz ścieżkę dźwiękową |
 |
- Set Audio Volume | + |
+ Ustaw głośność dźwięku |
 |
- Get Audio Volume | + |
+ Uzyskaj głośność dźwięku |
 |
- Set Master Volume | + |
+ Ustaw głośność główną |
 |
- Get Master Volume | + |
+ Uzyskaj głośność główną |
 |
- If Audio Is Playing | + |
+ Jeśli odtwarzany jest dźwięk |
 |
- If Audio Is Paused | -||
 |
- Set Audio Loop State | -||
 |
- Get Audio Loop State | -||
 |
- Set Audio Loop Start | -||
 |
- Get Audio Loop Start | -||
 |
- Set Audio Loop End | -||
 |
- Get Audio Loop End | + |
+ Jeśli dźwięk jest wstrzymany |
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
- - \ No newline at end of file + + \ No newline at end of file diff --git a/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Get_Audio_Length.htm b/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Get_Audio_Length.htm index 16c2cbbb2..18b8aa7c3 100644 --- a/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Get_Audio_Length.htm +++ b/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Get_Audio_Length.htm @@ -3,10 +3,10 @@ -
Get Audio LengthThis action can be used to retrieve the length of a sound in your game. You supply the sound resource to get the length of and a target variable to return the value too (or you can flag the target as a temp variable to have the action create the variable - for use until the end of the event or script). The length will be returned to the target variable (which can be made temporary) in seconds and can be a decimal value.
--
Ta akcja może być użyta do pobrania długości dźwięku w grze. Podajesz zasób dźwiękowy, którego długość ma zostać pobrana, oraz zmienną docelową, która ma zwrócić tę wartość (możesz też flag podać zmienną docelową jako zmienną tymczasową, aby akcja utworzyła zmienną + do wykorzystania do końca zdarzenia lub na stronie script). Długość zostanie zwrócona do zmiennej docelowej (którą można uczynić tymczasową) w sekundach i może być wartością dziesiętną.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Sound | -The sound resource to get the length of | +Sound | +Zasoby dźwiękowe pozwalające uzyskać długość |
| Target | -The target variable to store the return value | +Target | +Zmienna docelowa do przechowywania wartości zwracanej |
-
The above action block code gets the playing length of the given sound resource and stores
- it in a temporary local variable. This is then used to generate a random value between 0 and the length of the sound, which is then stored in a different temporary local variable. This new random value is then used to set the start position for the
- sound and the sound is then played.
-
-
+
+
Powyższy kod bloku akcji pobiera długość odtwarzania danego zasobu dźwiękowego i zapisuje ją
+ ją w tymczasowej zmiennej lokalnej. Następnie jest ona wykorzystywana do wygenerowania losowej wartości z przedziału od 0 do długości dźwięku, która jest zapisywana w innej tymczasowej zmiennej lokalnej. Ta nowa wartość losowa jest następnie używana do ustawienia pozycji startowej dla
+ a następnie dźwięk jest odtwarzany.
+
+
-
Get Audio Loop EndThis action gets the loop end position of the given audio and stores it in a variable.
--
| Argument | -Description | -
|---|---|
| Sound | -The sound asset or playing sound to | -
| Target | -The name of the variable in which to store the loop end | -
| Temp | -Whether the target variable should be a temporary variable | -
-
-
- - - - - \ No newline at end of file diff --git a/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Get_Audio_Loop_Start.htm b/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Get_Audio_Loop_Start.htm deleted file mode 100644 index 0dc18cd5c..000000000 --- a/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Get_Audio_Loop_Start.htm +++ /dev/null @@ -1,65 +0,0 @@ - - - - - -
Get Audio Loop StartThis action is used to get the start point of the audio's loop.
--
| Argument | -Description | -
|---|---|
| Sound | -The sound resource to set the pitch of | -
| Target | -The name of the variable in which to store the state | -
| Temp | -Whether the target variable should be a temporary variable (Declare Temporary Variable) | -
-
-
- - - - - \ No newline at end of file diff --git a/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Get_Audio_Loop_State.htm b/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Get_Audio_Loop_State.htm deleted file mode 100644 index c1a01c2b7..000000000 --- a/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Get_Audio_Loop_State.htm +++ /dev/null @@ -1,65 +0,0 @@ - - - - - -
Get Audio Loop StateThis action is used to get the loop state of a sound. You supply a sound, played with Play Audio and the target variable in which to store the result.
--
| Argument | -Description | -
|---|---|
| Sound | -The sound of which to get the loop state | -
| Target | -The name of the variable in which to store the state | -
| Temp | -Whether the target variable should be a temporary variable | -
-
-
- - - - - \ No newline at end of file diff --git a/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Get_Audio_Pitch.htm b/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Get_Audio_Pitch.htm index c3c175c4a..119bde37c 100644 --- a/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Get_Audio_Pitch.htm +++ b/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Get_Audio_Pitch.htm @@ -3,10 +3,10 @@ -
Get Audio PitchThis action will retrieve the pitch of the sound resource you supply. The return value will be a multiplier for the actual recorded pitch of the sample, where a value of 1 is no change. For more information on pitch see the action Set Audio Pitch.
--
Ta czynność spowoduje pobranie wysokości dźwięku z podanego zasobu. Zwracaną wartością będzie mnożnik dla aktualnie zarejestrowanej wysokości próbki, gdzie wartość 1 oznacza brak zmian. Więcej informacji o wysokości dźwięku można znaleźć w akcji Ustaw wysokość dźwięku.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Sound | -The sound resource to get the pitch of | +Sound | +Zasoby dźwiękowe do uzyskania wysokości dźwięku |
| Target | -The target variable to store the returned pitch | +Target | +Zmienna docelowa do przechowywania zwróconego skoku |
-
The above action block code first gets the pitch for the given sound and stores it in a temporary
- local variable. It then checks for a key press, and if one is detected, the value of the pitch is checked to see if it is less than 2. If it is, then the sound is stopped, the pitch variable has 0.1 added to it, and then this variable is used to set
- the pitch of the sound again before it is played.
-
-
+
+
Powyższy kod bloku akcji najpierw pobiera wysokość podanego dźwięku i zapisuje ją w tymczasowej
+ zmiennej lokalnej. Następnie sprawdza, czy nie został naciśnięty klawisz, a jeśli tak, to wartość pitch jest sprawdzana, czy jest mniejsza niż 2. Jeśli tak, to dźwięk jest zatrzymywany, do zmiennej pitch jest dodawana wartość 0,1, a następnie zmienna ta jest używana do ponownego ustawienia wysokości dźwięku przed jego odtworzeniem.
+ wysokości dźwięku przed jego odtworzeniem.
+
+
-
Get Audio VolumeThis action returns the volume of the given sound. You pick the sound from the asset explorer and give a target variable to return the volume value to (you can flag this as being a temporary local variable). The returned value will be between 0 and - 1, where 0 is silent and 1 is full volume.
--
Ta akcja zwraca głośność podanego dźwięku. Wybierasz dźwięk z eksploratora asset i podajesz zmienną docelową, do której ma zostać zwrócona wartość głośności (możesz flag, aby była to tymczasowa zmienna lokalna). Zwracana wartość będzie zawierać się w przedziale od 0 do + 1, gdzie 0 oznacza ciszę, a 1 pełną głośność.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Sound | -The sound resource to get the volume of | +Sound | +Zasoby dźwiękowe, aby uzyskać głośność |
| Target | -The target variable to store the returned volume | +Target | +Zmienna docelowa do przechowywania zwróconej objętości |
-
The above action block code checks a global variable to see if it is true or false. If it is true then the volume of the given sound is retrieved and stored in a temporary local variable. The value is then checked to see if it is not equal to 0.5, and if it is not, then the volume of the sound is set to 0.5. If
- the global variable evaluates to false, then the sound has its volume set to 1.
-
-
+
+
Powyższy kod bloku akcji sprawdza zmienną globalną, czy ma ona wartość true czy false. Jeśli jest to true, to pobierana jest głośność danego dźwięku i zapisywana w tymczasowej zmiennej lokalnej. Następnie sprawdzane jest, czy wartość ta nie jest równa 0,5, a jeśli nie, to głośność dźwięku jest ustawiana na 0,5. Jeśli
+ zmienna globalna ma wartość false, to głośność dźwięku jest ustawiana na 1.
+
+
-
Get Master VolumeThis action returns the master volume for the sound system. You give a target variable to return the volume value to (you can flag this as being a temporary local variable). The returned value will be between 0 and 1, where 0 is silent and 1 is full - volume.
--
To działanie zwraca główną głośność systemu dźwiękowego. Użytkownik podaje zmienną docelową, do której ma zostać zwrócona wartość głośności (można ją flag jako tymczasową zmienną lokalną). Zwracana wartość będzie zawierać się w przedziale od 0 do 1, gdzie 0 oznacza ciszę, a 1 pełną + głośność.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Target | -The target variable to store the returned volume | +Target | +Zmienna docelowa do przechowywania zwróconej objętości |
-
The above action block code checks a global variable to see if it is true or
- false. If it is true then the master volume for the sound system is retrieved and stored in a temporary local variable. The value is then checked to see if it is not equal to 0.5, and if it is not, then the master volume of the sound system
- is set to 0.5. If the global variable evaluates to false, then the master volume is set to 1.
-
-
+
+
Powyższy kod bloku akcji sprawdza zmienną globalną, czy ma ona wartość true czy
+ false. Jeśli jest to true, to pobierana jest wartość głośności głównej systemu dźwiękowego i zapisywana w tymczasowej zmiennej lokalnej. Następnie sprawdzane jest, czy wartość ta nie jest równa 0,5, a jeśli nie, to głośność główna systemu dźwiękowego
+ jest ustawiana na 0,5. Jeśli zmienna globalna ma wartość false, to głośność główna jest ustawiana na 1.
+
+
-
If Audio Is PausedThis action can be used to check whether an instance of any sound resource is currently paused in your game. You give the sound resource to check for from the asset explorer and the function will return true if it is paused and false - if it is not, although if you check the "not" flag, this is reversed and the function will return true if the sound is not paused and false otherwise.
-Note that to add actions into the "if" block, they should be dropped to the side of the action, as shown in the image below:
-
These actions will now be run if the "if" evaluates to true, while
- any actions dropped elsewhere will be performed after the "if" block.
-
Ta akcja może być użyta do sprawdzenia, czy instancja dowolnego zasobu dźwiękowego jest aktualnie wstrzymana w grze. Z eksploratora asset podajesz zasób dźwiękowy, który chcesz sprawdzić, a funkcja zwróci true if it is paused and false + jeśli tak nie jest, choć jeśli zaznaczysz opcję "not" flag, to sytuacja się odwróci i funkcja zwróci true, jeśli dźwięk nie jest wstrzymany, a false w przeciwnym wypadku.
+Należy pamiętać, że aby dodać akcje do bloku "jeśli", należy je upuścić z boku akcji, jak pokazano na poniższym rysunku:
+Te akcje będą teraz uruchamiane, jeśli "if" zakończy się wynikiem true, podczas gdy
+ wszelkie działania porzucone w innym miejscu zostaną wykonane po bloku "if".
+
| Argument | -Description | +Opis | |
|---|---|---|---|
| Sound | -The sound resource to check | +Sound | +Zasoby dźwięku do sprawdzenia |
-
The above action block code checks to see if the given sound is currently paused and
- if it is, it resumes playing it.
-
-
+
+
Powyższy kod bloku akcji sprawdza, czy dany dźwięk jest aktualnie wstrzymany i
+ jeśli tak, wznawia jego odtwarzanie.
+
+
-
If Audio Is PlayingThis action can be used to check whether an instance of any sound resource is currently playing in your game. You give the sound resource to check for from the asset explorer and the function will return true if it is playing and false - if it is not, although if you check the "not" flag, this is reversed and the function will return true if the sound is not playing and false otherwise.
-Note that to add actions into the "if" block, they should be dropped to the side of the action, as shown in the image below:
-
These actions will now be run if the "if" evaluates to true, while any
- actions dropped elsewhere will be performed after the "if" block.
-
Ta akcja może być użyta do sprawdzenia, czy w grze jest aktualnie odtwarzana instancja dowolnego zasobu dźwiękowego. Z eksploratora asset podajesz zasób dźwiękowy do sprawdzenia, a funkcja zwróci true if it is playing and false + jeśli tak nie jest, choć jeśli zaznaczysz opcję "not" flag, to sytuacja się odwróci i funkcja zwróci true, jeśli dźwięk nie jest odtwarzany, a false w przeciwnym wypadku.
+Należy pamiętać, że aby dodać akcje do bloku "jeśli", należy je upuścić z boku akcji, jak pokazano na poniższym rysunku:
+Te akcje będą teraz uruchamiane, jeśli "if" zakończy się wynikiem true, podczas gdy wszelkie
+ zostaną wykonane po bloku "if".
+
| Argument | -Description | +Opis | |
|---|---|---|---|
| Sound | -The sound resource to check | +Sound | +Zasoby dźwięku do sprawdzenia |
-
The above action block code checks to see if the given sound is currently being played
- and if it is, it stops it.
-
-
+
+
Powyższy kod bloku akcji sprawdza, czy dany dźwięk jest aktualnie odtwarzany
+ a jeśli tak, to go zatrzymuje.
+
+
-
Pause All AudioThis action can be used to pause all sounds currently playing, but this will not pause any sounds played after the action has been called. You can start them playing again using the action Resume All Audio.
--
The above action block code will check a global variable and if it evaluates to true then all sound is paused, otherwise it is all resumed.
-
-
+
Za pomocą tej akcji można wstrzymać wszystkie aktualnie odtwarzane dźwięki, ale nie wstrzyma to żadnych dźwięków odtwarzanych po wywołaniu tej akcji. Ich ponowne odtwarzanie można rozpocząć za pomocą akcji Wznów wszystkie dźwięki.
++
Powyższy kod bloku akcji sprawdzi zmienną globalną i jeśli jej wartość będzie równa true, dźwięk zostanie wstrzymany, a w przeciwnym razie zostanie wznowiony.
+
+
-
Pause AudioThis action can be used to pause the chosen sound if it is currently playing. Note if you have played multiple instances of the same sound, all of them will be paused, and this does not pause any sounds played after the action has been - called. You can start a paused sound playing again using the action Resume Audio.
--
Za pomocą tej akcji można wstrzymać odtwarzanie wybranego dźwięku, jeśli jest on aktualnie odtwarzany. Uwaga: jeśli odtworzono wiele instancji tego samego dźwięku, wszystkie zostaną wstrzymane, natomiast nie wstrzymuje to odtwarzania dźwięków odtwarzanych po wywołaniu tej akcji. + wywołaniu akcji. Odtwarzanie wstrzymanego dźwięku można wznowić za pomocą akcji Wznów dźwięk.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Sound | -The sound resource to pause | +Sound | +Przerwa w odtwarzaniu zasobów dźwiękowych |
-
The above action block code will check a global variable and if it evaluates to true then
- the given sound is paused, otherwise it is resumed.
-
-
+
+
Powyższy kod bloku akcji sprawdzi zmienną globalną i jeśli jej wartość będzie równa true, to
+ dany dźwięk zostanie wstrzymany, w przeciwnym razie zostanie wznowiony.
+
+
-
Play AudioThis action will set the given sound playing. You select the sound from the Asset Explorer and then set whether you would like the sound to be looped or not (a looped sound will play again and again between its loop start and end points until stopped) by setting the "Loop" flag.
-Additionally you can set the gain, the offset (the track position to start playing from) and the pitch to play the sound with.
-The final value for gain and pitch for the sound being played is the product of the values for gain and pitch set for the sound asset. The offset value is the value provided in the "Offset" field or the offset value of the sound asset being played when the field is left empty (see Example 2).
+Ta akcja ustawi odtwarzanie danego dźwięku. Wybierasz dźwięk z eksploratora Asset, a następnie ustawiasz, czy chcesz, aby dźwięk był zapętlony czy nie (zapętlony dźwięk będzie odtwarzany wielokrotnie aż do zatrzymania), ustawiając "Loop" flag.
+Dodatkowo można ustawić wzmocnienie, offset (pozycję ścieżki, od której należy rozpocząć odtwarzanie) oraz wysokość dźwięku, z jaką ma być odtwarzany.
+Ostateczna wartość wzmocnienia i wysokości odtwarzanego dźwięku jest iloczynem wartości wzmocnienia i wysokości ustawionych dla dźwięku asset. Wartość offsetu jest wartością podaną w polu "Offset" lub wartością offsetu odtwarzanego zasobu dźwiękowego, gdy pole pozostanie puste (patrz przykład 2).
| Argument | -Description | +Opis | |
|---|---|---|---|
| Sound | -The sound asset to play | +Sound | +Dźwięk asset do odtwarzania |
| Loop | -Whether to loop the sound or not (off by default) | +Loop | +Czy loop dźwięk czy nie (domyślnie wyłączony) |
| Target | -The target variable to store the return value | +Target | +Zmienna docelowa do przechowywania wartości zwrotnej |
| Gain | -Value for the gain multiplier (default 1). The gain multiplier set here is multiplied with the sound asset's gain multiplier | +Gain | +Wartość mnożnika wzmocnienia (domyślnie 1). Ustawiony tutaj mnożnik wzmocnienia jest mnożony przez mnożnik wzmocnienia zasobu dźwiękowego |
| Offset | -The time (in seconds) to set the start point to (default 0). Values beyond the end of the sound are clamped to its length. - The sound asset's offset (track position) is used when this field if left blank. |
+ Offset | +Czas (w sekundach), na który należy ustawić punkt startowy (domyślnie 0). Wartości dłuższe niż długość podanego dźwięku są ignorowane. + Jeśli to pole jest puste, używane jest przesunięcie zasobu dźwiękowego (pozycja ścieżki). |
| Pitch | -The pitch multiplier (default 1). The gain multiplier set here is multiplied with the sound asset's gain multiplier | +Pitch | +Mnożnik wysokości dźwięku (domyślnie 1). Ustawiony tutaj mnożnik wzmocnienia jest mnożony przez mnożnik wzmocnienia zasobu dźwiękowego |
-
The above action block code checks for a mouse button press and if one is detected it then checks a global variable to see if it is not true. If it is not true, then a sound is played (and looped) and the global variable set to true, otherwise the sound is stopped and the global variable is set to false.
- The sound is played with default settings: a gain and pitch multiplier of 1 and an offset of 0 (the default offset of the sound asset).
The above action block code first sets the track position of sound asset "snd_MusicBoss" to 20 seconds. It then checks if the instance variable "skip_intro" is set to true. If it is, it starts playing "snd_MusicBoss" at 20 seconds, the value for track position set earlier (this is because the "Offset" field is left blank so the asset offset is used). The first 20 seconds of the audio are skipped.
- If the instance variable "skip_intro" is set to false, it also starts playing "snd_MusicBoss" but, because the "Offset" has been set to 0, the sound will start playing from the start. The track position of 20 seconds as defined earlier for the sound asset is ignored.
-
+
+
Powyższy kod bloku akcji sprawdza, czy nie nastąpiło naciśnięcie przycisku myszy, a jeśli tak, to sprawdza zmienną globalną, czy nie jest to true. Jeśli nie jest to true, to odtwarzany jest dźwięk (i zapętlany), a zmienna globalna ustawiana jest na true, w przeciwnym razie dźwięk jest zatrzymywany, a zmienna globalna ustawiana jest na false.
+ Dźwięk jest odtwarzany z domyślnymi ustawieniami: mnożnik wzmocnienia i wysokości dźwięku równy 1 oraz offset równy 0 (domyślny offset dźwięku asset).
Powyższy kod bloku akcji ustawia najpierw pozycję ścieżki dźwięku asset "snd_MusicBoss" na 20 sekund. Następnie sprawdza, czy zmienna instancji "skip_intro" jest ustawiona na true. Jeśli tak, to rozpoczyna odtwarzanie dźwięku "snd_MusicBoss" od 20 sekundy, czyli od wartości dla pozycji ścieżki ustawionej wcześniej (dzieje się tak dlatego, że pole "Offset" jest pozostawione puste, więc używany jest offset aktywów ). Pierwsze 20 sekund dźwięku jest pomijane.
+ Jeśli zmienna instancji "skip_intro" jest ustawiona na false, to rozpoczyna się również odtwarzanie "snd_MusicBoss", ale ponieważ "Offset" został ustawiony na 0, dźwięk rozpocznie się od początku. Pozycja ścieżki 20 sekund, zdefiniowana wcześniej dla zasobu dźwiękowego, jest ignorowana.
+
-
Resume All AudioThis action can be used to resume all previously paused sounds that have been paused using Pause Audio or Pause All Audio. It will have no effect on those sounds that have not been paused - previously.
--
The above action block code will check a global variable and if it evaluates to true then all sound is paused, otherwise it is all resumed.
-
-
+
Za pomocą tej akcji można wznowić odtwarzanie wszystkich wcześniej wstrzymanych dźwięków, które zostały wstrzymane za pomocą funkcji Wstrzymaj dźwięk lub Wstrzymaj wszystkie dźwięki. Nie ma ona wpływu na dźwięki, które nie zostały wcześniej wstrzymane. + wcześniej.
++
Powyższy kod bloku akcji sprawdzi zmienną globalną i jeśli jej wartość będzie równa true, dźwięk zostanie wstrzymany, a w przeciwnym razie zostanie wznowiony.
+
+
-
Resume AudioThis action can be used to resume a previously paused sound. This can be used on any sound that has been paused using Pause Audio or Pause All Audio, and will have no effect on those sounds - that have not been paused previously.
--
Ta akcja umożliwia wznowienie odtwarzania wcześniej wstrzymanego dźwięku. Można tego użyć w przypadku każdego dźwięku, który został wstrzymany za pomocą funkcji Wstrzymaj dźwięk lub Wstrzymaj wszystkie dźwięki, ale nie będzie to miało wpływu na dźwięki, które nie zostały wcześniej wstrzymane. + które nie zostały wcześniej wstrzymane.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Sound | -The sound resource to resume playing | +Sound | +Zasób dźwiękowy do wznowienia odtwarzania |
-
The above action block code will check a global variable and if it evaluates to true then
- the given sound is paused, otherwise it is resumed.
-
-
+
+
Powyższy kod bloku akcji sprawdzi zmienną globalną i jeśli jej wartość będzie równa true, to
+ dany dźwięk zostanie wstrzymany, w przeciwnym razie zostanie wznowiony.
+
+
-
Set Audio Loop EndThis action can be used to set the loop state of a sound.
--
| Argument | -Description | -
|---|---|
| Sound | -The sound resource to set the pitch of | -
| Offset | -The track offset (for the loop end, 0.0 indicates the end of the audio) | -
-
-
- - - - - \ No newline at end of file diff --git a/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Set_Audio_Loop_Start.htm b/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Set_Audio_Loop_Start.htm deleted file mode 100644 index f646955b1..000000000 --- a/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Set_Audio_Loop_Start.htm +++ /dev/null @@ -1,61 +0,0 @@ - - - - - -
Set Audio Loop StartThis action is used to set the loop start point of a sound.
--
| Argument | -Description | -
|---|---|
| Sound | -The Sound Asset or sound instance | -
| Offset | -The track offset (0.0 is the start of the audio) | -
-
-
- - - - - \ No newline at end of file diff --git a/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Set_Audio_Loop_State.htm b/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Set_Audio_Loop_State.htm deleted file mode 100644 index 2ddd19de0..000000000 --- a/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Set_Audio_Loop_State.htm +++ /dev/null @@ -1,61 +0,0 @@ - - - - - -
Set Audio Loop StateThis action is used to set the loop state of an already playing sound, i.e. one played with the Play Audio action.
--
| Argument | -Description | -
|---|---|
| Sound | -The sound, played with Play Audio, to set the loop state of | -
| Loop | -Whether to loop the sound between its loop start and end or not (true or false) | -
-
-
- - - - - \ No newline at end of file diff --git a/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Set_Audio_Pitch.htm b/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Set_Audio_Pitch.htm index b5c510756..e6016661c 100644 --- a/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Set_Audio_Pitch.htm +++ b/Manual/contents/Drag_And_Drop/Drag_And_Drop_Reference/Audio/Set_Audio_Pitch.htm @@ -3,10 +3,10 @@ -
Set Audio PitchThis action can be used to set the pitch of a sound. You supply the sound asset from the Asset Browser, and then give the desired pitch to change it to, and all further instances of that sound which you play will have their pitch changed. This action will not change the pitch of any sound currently playing, however, and should be used before you use the Play Audio action for the sound.
-The pitch value is a pitch multiplier, in that the input value multiplies the current pitch by that amount, so the default value of 1 is no pitch change, while a value of less than 1 will lower the pitch and greater than 1 will raise the pitch. It is best to use small increments for this function as any value under 0 or over 5 may not be audible anyway. It is worth noting that the total pitch change permitted is clamped to (1/256) - 256 octaves, so any value over or under this will not be registered.
-The clamped value given above is what GameMaker attempts to clamp the range to, but this value is not guaranteed on all target platforms. iOS, for example, clamps to (1/256) - 8, so you may need to experiment on each target platform and have different versions of a sound resource, each one pre-shifted, should you require higher or lower octave values.
--
Tej akcji można użyć do ustawienia wysokości dźwięku. Dźwięk należy podać na stronie asset w przeglądarce Asset, a następnie określić żądaną wysokość dźwięku, na którą ma zostać zmieniony. Ta czynność + nie zmieni wysokości aktualnie odtwarzanego dźwięku i powinna być stosowana przed użyciem akcji Odtwórz dźwięk dla danego dźwięku.
+Wartość pitch jest mnożnikiem wysokości dźwięku, co oznacza, że wartość wejściowa mnoży bieżącą wysokość dźwięku przez tę wartość. Wartość domyślna 1 nie powoduje zmiany wysokości dźwięku, natomiast wartość mniejsza niż 1 obniża wysokość dźwięku, a większa niż 1 podwyższa ją. + W przypadku tej funkcji najlepiej jest stosować małe przyrosty, ponieważ wartości poniżej 0 lub powyżej 5 mogą być niesłyszalne. Warto zauważyć, że całkowita dozwolona zmiana wysokości dźwięku jest ograniczona do (1/256) - 256 oktaw, więc wszelkie wartości powyżej lub poniżej tej wartości nie będą + zarejestrowana.
+UWAGA: Podana powyżej wartość zacisku jest tym, do czego GameMaker próbuje zacisnąć zakres, ale nie jest to gwarantowane na wszystkich platformach docelowych. iOS na przykład, zaciska się na (1/256) - 8, więc możesz potrzebować poeksperymentować na każdej platformie docelowej + i mieć różne wersje zasobów dźwiękowych, z których każda jest wstępnie przesunięta, jeśli potrzebujesz wyższych lub niższych wartości oktaw.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Sound | -The sound resource to set the pitch of | +Sound | +Zasób dźwiękowy do ustawiania wysokości dźwięku |
| pitch | -The pitch to set the sound to (default is 1) | +pitch | +Wysokość dźwięku, na którą ma być ustawiony dźwięk (domyślnie 1) |
-
The above action block code first gets the pitch for the given sound and stores it in a temporary local variable. It then checks for a key press, and if one is detected, the value of the pitch is checked to see if it is less than 2. If it is, then the sound is stopped, the pitch variable has 0.1 added to it, and then this variable is used to set the pitch of the sound again before it is played.
-
-
+
+
Powyższy kod bloku akcji najpierw pobiera wysokość podanego dźwięku i zapisuje ją w tymczasowej
+ zmiennej lokalnej. Następnie sprawdza, czy nie został naciśnięty klawisz, a jeśli tak, to wartość pitch jest sprawdzana, czy jest mniejsza niż 2. Jeśli tak, to dźwięk jest zatrzymywany, do zmiennej pitch dodawana jest wartość 0,1, a następnie zmienna ta jest używana do ponownego ustawienia wysokości dźwięku przed jego odtworzeniem.
+ wysokości dźwięku przed jego odtworzeniem.
+
+
-
Set Audio PositionWith this action you can set a sound to start from a specific time.
-You give the sound to play, and the time to start it from, but this action will not play the sound for you, it will simply set the play position for the sound. To use this action you must first set the position then play the sound using the action Play Audio, otherwise you will here no change in position until the next time you play the same sound resource (which will start at the new position).
-The position is set in seconds - you can use decimal values - and you can get the total sound length using the action Get Audio Length.
-Values beyond the end of the sound are clamped to its length.
--
Za pomocą tej akcji można ustawić dźwięk, który ma być odtwarzany o określonej godzinie. Użytkownik podaje dźwięk, który ma być odtwarzany, oraz godzinę rozpoczęcia odtwarzania, ale ta akcja nie odtworzy dźwięku za niego, lecz po prostu ustawi pozycję odtwarzania dźwięku. Aby użyć tej akcji + musisz najpierw ustawić pozycję, a następnie odtworzyć dźwięk za pomocą akcji Odtwórz dźwięk, w przeciwnym razie nie zobaczysz zmiany pozycji aż do następnego odtworzenia tego samego zasobu dźwiękowego (który rozpocznie się na + nowej pozycji). Pozycję ustawia się w sekundach - można użyć wartości dziesiętnych - a całkowitą długość dźwięku można uzyskać za pomocą akcji Get Audio Length, choć jeśli podamy wartość większą niż długość + Jeśli więc dźwięk ma mieć długość 10 sekund, a jako pozycję początkową podano 12 sekund, dźwięk rozpocznie się w 2 sekundzie.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Sound | -The sound resource to set the play position of | +Sound | +Zasób dźwiękowy do ustawiania pozycji odtwarzania |
| Time | -The time to set (in seconds) | +Time | +Czas do ustawienia (w sekundach) |
-
The above action block code gets the playing length of the given sound resource and stores it in a temporary local variable. This is then used to generate a random value between 0 and the length of the sound, which is then stored in a different temporary local variable. This new random value is then used to set the start position for the sound and the sound is then played.
-
-
+
+
Powyższy kod bloku akcji pobiera długość odtwarzania danego zasobu dźwiękowego i zapisuje ją
+ ją w tymczasowej zmiennej lokalnej. Następnie jest ona wykorzystywana do wygenerowania losowej wartości z przedziału od 0 do długości dźwięku, która jest zapisywana w innej tymczasowej zmiennej lokalnej. Ta nowa wartość losowa jest następnie używana do ustawienia pozycji startowej dla
+ a następnie dźwięk jest odtwarzany.
+
+
-
Set Audio VolumeWith this action you can set the volume of a given sound. You select the sound from the asset explorer and then set the volume value. The volume can be between 0 (silent) and 1 (full volume) and the scale is linear, such that a value of 0.5 would be half volume. Note that this action will affect all instances of the sound that are playing currently in the room, and will affect all future instances of the sound played.
-The "Time" field controls how long it takes for the volume change to take effect. A value of 0 results in an instant change, where a larger value will gradually change the volume over the given amount of milliseconds.
-+
Dzięki tej akcji możesz ustawić głośność danego dźwięku. Wybierasz dźwięk z eksploratora asset, a następnie ustawiasz wartość głośności. Głośność może mieć wartość od 0 (cichy) do 1 (pełna głośność), a skala jest liniowa, tak że wartość 0,5 oznacza połowę głośności. Zauważ, że ta akcja wpłynie na wszystkie instancje dźwięku, które są odtwarzane obecnie w room, a także wpłynie na wszystkie przyszłe instancje odtwarzanego dźwięku.
+Pole "Time" kontroluje, jak długo trwa zmiana głośności. Wartość 0 powoduje natychmiastową zmianę, gdzie większa wartość będzie stopniowo zmieniać głośność w ciągu danej ilości milisekund.
+
| Argument | -Description | +Opis | |
|---|---|---|---|
| Sound | -The sound resource to set the volume of | +Sound | +Zasób dźwięków do ustawienia głośności |
| Volume | -The new volume for the sound (from 0 to 1, default 1) | +Volume | +Nowa głośność dla dźwięku (od 0 do 1, domyślnie 1) |
| Time | -The amount of time over which to fade the volume (in milliseconds). | +Time | +Czas, w którym ma nastąpić zanik głośności (w milisekundach). |
-
The above action block code checks a global variable to see if it is true or false. If it is true then the volume of the given sound is retrieved and stored in a temporary local variable. The value is then checked to see if it is not equal to 0.5, and if it is not, then the volume of the sound is set to fade to 0.5 in 1000 milliseconds (1 second). If the global variable evaluates to false, then the sound has its volume set to 1. As the value for time is set to 0 here, the change in volume occurs immediately.
-
-
+
+
Powyższy kod bloku akcji sprawdza zmienną globalną, czy ma ona wartość true czy false. Jeśli jest true to pobierana jest głośność danego dźwięku i zapisywana w tymczasowej zmiennej lokalnej. Wartość ta jest następnie sprawdzana, czy nie jest równa 0.5, a jeśli nie jest, to głośność dźwięku jest ustawiana na zanikanie do 0.5 w ciągu 1000 milisekund (1 sekundy). Jeżeli zmienna globalna ma wartość false, to dźwięk ma ustawioną głośność na 1. Ponieważ wartość czasu jest tutaj ustawiona na 0, zmiana głośności następuje natychmiast.
+
+
-
Set Master VolumeWith this action you can set the volume for the whole sound system. The volume value you give can be between 0 (silent) and 1 (full volume) and the scale is linear, such that a value of 0.5 would be half volume. Note that this action will affect all - instances of all sounds that are playing currently in the room, and will affect all future instances of all sounds played. This action is also independent of the volume set for any individual sound, so if you have a sound set to play at 0.5 volume - and then set the master volume to 0.5, the sound will play at 0.25 volume.
--
Za pomocą tej czynności można ustawić głośność dla całego systemu dźwiękowego. Podawana wartość głośności może wynosić od 0 (cisza) do 1 (pełna głośność), a skala jest liniowa, czyli wartość 0,5 oznacza połowę głośności. Należy pamiętać, że to działanie będzie miało wpływ na wszystkie + wszystkie instancje wszystkich dźwięków odtwarzanych aktualnie w witrynie room, a także wpłynie na wszystkie przyszłe instancje wszystkich odtwarzanych dźwięków. Działanie to jest również niezależne od głośności ustawionej dla poszczególnych dźwięków, więc jeśli dźwięk ma być odtwarzany z głośnością 0,5 + a następnie ustawisz głośność główną na 0,5, dźwięk ten będzie odtwarzany z głośnością 0,25.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Volume | -The new master volume for all sound (from 0 to 1, default 1) | +Volume | +Nowa głośność główna dla wszystkich dźwięków (od 0 do 1, domyślnie 1) |
-
The above action block code checks a global variable to see if it is true or
- false. If it is true then the master volume for the sound system is retrieved and stored in a temporary local variable. The value is then checked to see if it is not equal to 0.5, and if it is not, then the master volume of the sound system
- is set to 0.5. If the global variable evaluates to false, then the master volume is set to 1.
-
-
+
+
Powyższy kod bloku akcji sprawdza zmienną globalną, czy ma ona wartość true czy
+ false. Jeśli jest to true, to pobierana jest główna głośność systemu dźwiękowego i zapisywana w tymczasowej zmiennej lokalnej. Następnie sprawdzane jest, czy wartość ta nie jest równa 0,5, a jeśli nie, to głośność główna systemu dźwiękowego
+ jest ustawiana na 0,5. Jeśli zmienna globalna ma wartość false, to głośność główna jest ustawiana na 1.
+
+
-
Stop All AudioThis action can be used to stop all audio that is currently playing (note that even if audio is flagged as paused it will be stopped with this function and you cannot resume it again later).
--
-
The above action block code checks for a mouse button press and if one is detected it then checks
- a global variable to see if it is not true. If it is not true, then a sound is played and the global variable set to true, otherwise all sound is stopped and the global variable is set to false.
-
-
-
+
Za pomocą tej akcji można zatrzymać cały aktualnie odtwarzany dźwięk (należy pamiętać, że nawet jeśli dźwięk jest oznaczony jako wstrzymany, zostanie zatrzymany za pomocą tej funkcji i nie będzie można go później wznowić).
++
+
Powyższy kod bloku akcji sprawdza, czy nie został naciśnięty przycisk myszy, a jeśli zostanie wykryty, sprawdza
+ zmienną globalną, czy nie jest ona prawdziwa. Jeśli nie jest to prawda, odtwarzany jest dźwięk, a zmienna globalna jest ustawiana na true, w przeciwnym razie dźwięk jest zatrzymywany, a zmienna globalna jest ustawiana na false.
+
+
+
-
Stop AudioThis action can be used to stop a sound from playing. You select the sound from the asset explorer and all instances of that sound will stop playing (so if you have set the same sound to play in three different events then all of them will stop).
--
Tej akcji można użyć do zatrzymania odtwarzania dźwięku. Użytkownik wybiera dźwięk z eksploratora asset, a wszystkie jego instancje przestaną być odtwarzane (jeśli więc ten sam dźwięk ma być odtwarzany w trzech różnych wydarzeniach, wszystkie zostaną zatrzymane).
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Sound | -The sound resource to stop | +Sound | +Zasoby dźwiękowe przestają działać |
-
The above action block code checks for a mouse button press and if one is detected it then checks a
- global variable to see if it is not true. If it is not true, then a sound is played (and looped) and the global variable set to true, otherwise the sound is stopped and the global variable is set to false.
-
-
+
+
Powyższy kod bloku akcji sprawdza, czy nie został naciśnięty przycisk myszy, a jeśli zostanie wykryty, sprawdza zmienną
+ zmienną globalną, aby sprawdzić, czy nie jest ona prawdziwa. Jeśli nie jest to prawda, to odtwarzany jest dźwięk (i zapętlany), a zmienna globalna jest ustawiana na true, w przeciwnym razie dźwięk jest zatrzymywany, a zmienna globalna jest ustawiana na false.
+
+
-
A buffer is a region of physical memory used to temporarily hold data while it is being moved from one place to another or manipulated in some way, for example you can use a buffer to hold game state data. GameMaker has a number of specific actions related to creating, modifying and loading/saving buffers, but before using them please note the following points:
+Bufor to obszar pamięci fizycznej używany do tymczasowego przechowywania danych podczas przenoszenia ich z jednego miejsca w inne lub manipulowania nimi w jakiś sposób, na przykład można użyć buffer do przechowywania danych o stanie gry. W programie GameMaker jest wiele specjalnych działań związanych z tworzeniem, modyfikowaniem i ładowaniem/zapisywaniem buffers, ale przed ich użyciem należy zwrócić uwagę na następujące kwestie:
The memory used for creating buffers is system memory so even when the game doesn't have focus, any data stored in a buffer should be safe, however if the app is closed or re-started then it will be lost. It is also worth noting that buffers can also be saved as files then loaded back into the game using the file actions.
-The following page explains in more detail how buffers work within the context of GameMaker and contain a couple of GML code examples:
+Pamięć używana do tworzenia buffers jest pamięcią systemową, więc nawet jeśli gra nie jest skoncentrowana, wszelkie dane zapisane w buffer powinny być bezpieczne, ale jeśli aplikacja zostanie zamknięta lub ponownie uruchomiona, zostaną utracone. Warto również zauważyć, że stronę buffers można również zapisać jako plik, a następnie załadować z powrotem do gry za pomocą akcji plikowych.
+Na następnej stronie wyjaśniono bardziej szczegółowo, jak działa strona buffers w kontekście programu GameMaker, oraz zamieszczono kilka przykładów kodu GML:
-The Buffer library has the following actions:
-+
Biblioteka Bufor wykonuje następujące czynności:
+
 |
- Create Buffer | +Utwórz bufor |
 |
- Copy Buffer | +Bufor kopiowania |
 |
- Delete Buffer | +Usuń bufor |
 |
- Read Buffer | +Bufor odczytu |
 |
- Write Buffer | +Bufor zapisu |
 |
- Seek Buffer | +Bufor poszukiwań |
 |
- Get Buffer Size | +Pobierz Buffer Rozmiar |
 |
- Get Buffer Position | +Pobierz Buffer Pozycja |
 |
- If Buffer Exists | +Jeśli istnieje strona Buffer |
 |
@@ -75,34 +75,34 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
Copy BufferThis action can be used to copy all of the data stored in one buffer to another. When using two buffers and copying from one to the other, both buffers must have previously been created using the Create Buffer action, and you supply the unique buffer ID returned as the from/to arguments.
-You cannot copy to the same buffer.
--
Tej akcji można użyć do skopiowania wszystkich danych przechowywanych w jednej witrynie buffer do drugiej. W przypadku korzystania z dwóch stron buffers i kopiowania danych z jednej do drugiej, obie strony buffers muszą być wcześniej utworzone za pomocą akcji Utwórz bufor, + a jako argumenty od/do należy podać unikalne identyfikatory buffer zwrócone przez użytkownika.
+UWAGA: Nie można kopiować na tę samą stronę buffer.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Buffer | -The buffer index (stored in a variable) to copy from | +Buffer | +Indeks buffer (przechowywany w zmiennej) do skopiowania z |
| Copy To | -The buffer index (stored in a variable) to copy to | +Copy To | +Indeks buffer (przechowywany w zmiennej), który ma zostać skopiowany do |
-
The above action block code will create a new buffer and store its ID in a temporary variable. It then checks to see if the buffer indexed in the given global variable exists, and if it does then it is copied to the temporary buffer and the read/write position reset back to the start, and if it doesn't exists then it is created.
-
-
+
+
Powyższy kod bloku akcji utworzy nową stronę buffer i zapisze jej identyfikator w zmiennej tymczasowej.
+ Następnie sprawdza, czy istnieje strona buffer indeksowana w podanej zmiennej globalnej, a jeśli tak, to kopiuje ją do tymczasowej strony buffer i przywraca początkową pozycję odczytu/zapisu, a jeśli nie istnieje, to ją tworzy.
+
+
-
Create BufferThis action can be used to allocate a portion of memory as a buffer in your game, with the function returning the unique buffer id value that should be stored in a variable and used for all further function calls to the buffer. You can supply a global variable, an instance variable or have the action create a temporary local variable for storing the buffer ID. Note that you can create additional buffers by clicking the plus icon 
beside the action, and selecting another variable to hold the buffer ID.
It's important that you remove any dynamically created resources like this from memory when you no longer need them to prevent memory leaks, so when you are finished with the buffer that you have created you should free it up again using Delete Buffer action (in the Other - Clean Up event, for example). This is especially important to remember when using a temporary local variable, as if you do not remove the buffer again before the end of the event or action script then you will no longer be able access it and can have issues later.
--
Tej akcji można użyć do alokacji fragmentu pamięci jako buffer w grze, przy czym funkcja zwraca unikatową wartość identyfikatora bufora, która powinna być przechowywana w zmiennej i używana we wszystkich dalszych wywołaniach funkcji na stronie buffer. Można podać
+ zmienną globalną, zmienną instancji lub zlecić akcji utworzenie tymczasowej zmiennej lokalnej do przechowywania identyfikatora buffer. Zauważ, że możesz utworzyć dodatkowe strony buffers, klikając ikonę plusa obok strony .
+ akcji i wybierając kolejną zmienną, która będzie przechowywać identyfikator buffer.
UWAGA: Ważne jest, aby usuwać dynamicznie tworzone zasoby z pamięci, gdy nie są już potrzebne, aby zapobiec wyciekom pamięci, dlatego po zakończeniu pracy z utworzonym buffer należy go ponownie zwolnić + używając akcji Delete Buffer (na przykład w zdarzeniu Other - Clean Up ). Jest to szczególnie ważne, gdy używasz tymczasowej zmiennej lokalnej + ponieważ jeśli nie usuniesz buffer ponownie przed zakończeniem zdarzenia lub akcji script, nie będziesz miał do niej dostępu i możesz mieć później problemy.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Buffer | -The buffer index (stored in a variable) | +Buffer | +Indeks buffer (przechowywany w zmiennej) |
| Value | -The value to add into the list | +Value | +Wartość, która ma zostać dodana do listy |
-
The above action block code creates a global variable and then a buffer, assigning the unique buffer ID to the variable. This buffer than has two pieces of data written to it.
-
-
+
+
Powyższy kod bloku akcji tworzy zmienną globalną, a następnie buffer, przypisując do niej unikalny
+ buffer ID do zmiennej. Na stronie buffer zapisywane są następnie dwie porcje danych.
+
+
-
Delete BufferThis action can be used to delete a buffer from memory, releasing the resources used to create it and removing any data that it may currently contain. You supply the unique buffer ID value as returned by the action Create Buffer. Note that you can select multiple buffers for removal by clicking the plus icon beside the action, and adding another buffer ID.
It's important to always remove any dynamically created resources from memory when you no longer need them to prevent memory leaks.
--
Tej akcji można użyć do usunięcia strony buffer z pamięci, zwalniając zasoby wykorzystane do jej utworzenia i usuwając wszelkie dane, które może ona aktualnie zawierać. Należy podać unikatową wartość identyfikatora buffer zwróconą przez akcję Utwórz bufor.
+ Zauważ, że do usunięcia można wybrać wiele stron buffers, klikając ikonę plusa obok tej akcji i dodając
+ kolejny identyfikator buffer.
UWAGA: Ważne jest, aby zawsze usuwać dynamicznie tworzone zasoby z pamięci, gdy nie są już potrzebne, aby zapobiec wyciekom pamięci.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Buffer | -The buffer index (stored in a variable) | +Buffer | +Indeks buffer (przechowywany w zmiennej) |
-
The above action block code checks to see if a buffer exists and if it does it is deleted.
-
-
+
+
Powyższy kod bloku akcji sprawdza, czy strona buffer istnieje, a jeśli tak, to jest usuwana.
+
+
-
Get Buffer PositionThis action can be used to retrieve the current position for reading/writing to the buffer. When you create a buffer, the read/write position is set at 0 bytes, and as you add data to the buffer this position will move along sequentially, meaning that - you can use this action to get the number of bytes into the buffer that it is set to at any time. You supply the unique buffer ID value as returned by the action Create Buffer and then give a target variable to return - the position value to. The target variable can be flagged as being a temporary local variable, in which case it will be created for you and removed from memory again at the end of the current action script or event.
--
Tej akcji można użyć do pobrania bieżącej pozycji odczytu/zapisu na stronie buffer. Podczas tworzenia strony buffer pozycja odczytu/zapisu jest ustawiona na 0 bajtów, a w miarę dodawania danych do strony buffer pozycja ta będzie się kolejno przesuwać, co oznacza, że + można użyć tej akcji, aby uzyskać liczbę bajtów w buffer, która jest ustawiona w dowolnym momencie. Użytkownik podaje unikatową wartość identyfikatora buffer zwróconą przez akcję Create Buffer, a następnie podaje zmienną docelową, która ma zwrócić + wartość pozycji. Zmienna docelowa może zostać oznaczona jako tymczasowa zmienna lokalna, w którym to przypadku zostanie utworzona i usunięta z pamięci po zakończeniu bieżącej akcji script lub zdarzenia.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Buffer | -The buffer index (stored in a variable) | +Buffer | +Indeks buffer (przechowywany w zmiennej) |
| Position | -The read/write position (in bytes) within the buffer | +Position | +Pozycja odczytu/zapisu (w bajtach) w buforze |
-
The above action block code gets the read/write position for the given buffer
- and if it is not 0 (ie: at the start of the buffer) it is set to the start of the buffer.
-
-
+
+
Powyższy kod bloku akcji pobiera pozycję odczytu/zapisu dla podanego bufora
+ i jeśli nie jest ona równa 0 (tzn. na początku strony buffer), to jest ustawiana na początek strony buffer.
+
+
-
Get Buffer SizeThis action can be used to retrieve the size of a buffer, in bytes. You supply the unique buffer ID value as returned by the action Create Buffer and then give a target variable to return the size value to. The target - variable can be flagged as being a temporary local variable, in which case it will be created for you and removed from memory again at the end of the current action script or event.
--
Tej akcji można użyć do pobrania rozmiaru strony buffer w bajtach. Należy podać unikatową wartość identyfikatora buffer zwróconą przez akcję Utwórz bufor, a następnie podać zmienną docelową, do której zostanie zwrócona wartość rozmiaru. Zmienna docelowa + może zostać oznaczona jako tymczasowa zmienna lokalna, w którym to przypadku zostanie utworzona i usunięta z pamięci po zakończeniu bieżącej akcji script lub zdarzenia.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Buffer | -The buffer index (stored in a variable) | +Buffer | +Indeks buffer (przechowywany w zmiennej) |
| Target | -The target variable to hold the returned value | +Target | +Zmienna docelowa, która ma przechowywać zwróconą wartość |
-
The above action block code gets the size of the buffer and then uses that value to set the
- read/write position to the end of the currently stored data.
-
-
+
+
Powyższy kod bloku akcji pobiera rozmiar strony buffer, a następnie wykorzystuje tę wartość do ustawienia pozycji
+ odczytu/zapisu na koniec aktualnie przechowywanych danych.
+
+
-
If Buffer ExistsThis action can be used to check if a given buffer ID is valid and the buffer actually exists in memory. If the buffer ID is valid and exists, the action will return true otherwise it will return false. You can flag "not" - to make the action check if a buffer does not exist.
-Note that to add actions into the "if" block, they should be dropped to the side of the action, as shown in the image below:
+Tej akcji można użyć do sprawdzenia, czy podany identyfikator buffer jest poprawny i czy adres buffer rzeczywiście istnieje w pamięci. Jeśli identyfikator buffer jest poprawny i istnieje, akcja zwróci true, w przeciwnym razie zwróci false. Możesz flag "not" + aby akcja sprawdzała, czy identyfikator buffer nie istnieje.
+Należy pamiętać, że aby dodać akcje do bloku "jeśli", należy je upuścić z boku akcji, jak pokazano na poniższym rysunku:
+
+
-
| Argument | -Description | +Opis | |
|---|---|---|---|
| Buffer | -The buffer index (stored in a variable) | +Buffer | +Indeks buffer (przechowywany w zmiennej) |
-
The above action block code checks to see if a buffer exists and if it does it is deleted.
-
-
+
+
Powyższy kod bloku akcji sprawdza, czy strona buffer istnieje, a jeśli tak, to jest usuwana.
+
+
-
If End Of BufferThis action can be used to check if the read/write position has reached the end of the buffer. You supply the unique buffer ID value as returned by the action Create Buffer and then the action will return true if the read/write position has reached the end of all the available data in the buffer, or false if it has not. You can flag "not" to make the action check if the read/write position is not at the end of the buffer.
-Note that to add actions into the "if" block, they should be dropped to the side of the action, as shown in the image below:
+Tej akcji można użyć do sprawdzenia, czy pozycja odczytu/zapisu osiągnęła koniec buffer. Należy podać unikatową wartość identyfikatora buffer zwróconą przez akcję Create Buffer, a następnie akcja zwróci wartość true, jeśli pozycja odczytu/zapisu osiągnęła koniec wszystkich dostępnych danych w buffer, lub false, jeśli nie osiągnęła. Aby akcja sprawdzała, czy pozycja odczytu/zapisu nie znajduje się na końcu listy flag, można wybrać opcję buffer "not" .
+Należy pamiętać, że aby dodać akcje do bloku "jeśli", należy je upuścić z boku akcji, jak pokazano na poniższym rysunku:
+
+
-
| Argument | -Description | +Opis | |
|---|---|---|---|
| Buffer | -The buffer index (stored in a variable) | +Buffer | +Indeks buffer (przechowywany w zmiennej) |
-
The above action block code creates a DS list in the instance and then loops through the
- data within the given buffer reading out the data and adding it to the list. This continues until the end of the buffer is reached at which time the loop is broken.
-
-
+
+
Powyższy kod bloku akcji tworzy w instancji listę DS, a następnie loops przegląda
+ danych w obrębie danej buffer odczytując dane i dodając je do listy. Czynność ta jest kontynuowana aż do osiągnięcia końca strony buffer, po czym następuje przerwanie strony loop.
+
+
-
Read BufferThis action can be used to read data from a previously created buffer. You supply the unique buffer ID value (as returned by the action Create Buffer) and give a variable to store the returned value. If you flag the variable - as a temporary local variable then it will be created for you and discarded again at the end of the event or action script. All data is returned as a string so if you have stored any real numbers you will have to use one of the Data Type Actions to convert it from the string to the value. Keep in mind too that buffers are read and written to sequentially and so reading from a buffer will move the "seek" position to the next entry, meaning that to read various pieces of data - you simply call this action the number of times required and store each returned piece of data to a variable.
--
Tej akcji można użyć do odczytu danych z wcześniej utworzonej strony buffer. Użytkownik podaje unikatową wartość identyfikatora buffer (zwróconą przez akcję Utwórz bufor) i podaje zmienną, w której ma być przechowywana zwrócona wartość. Jeśli flag zmienna + jako tymczasowa zmienna lokalna, zostanie ona utworzona dla Ciebie i usunięta po zakończeniu zdarzenia lub akcji script. Wszystkie dane są zwracane w postaci łańcucha znaków, więc jeśli przechowujesz jakieś liczby rzeczywiste, będziesz musiał użyć jednej z akcji typu danych, aby przekonwertować je z string na wartość. Należy też pamiętać, że strony buffers są odczytywane i zapisywane sekwencyjnie, więc odczyt z buffer spowoduje przesunięcie pozycji "szukania" do następnego wpisu, co oznacza, że aby odczytać różne dane + wystarczy wywołać tę czynność tyle razy, ile jest to wymagane, i zapisać każdą zwróconą porcję danych do zmiennej.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Buffer | -The buffer index (stored in a variable) | +Buffer | +Indeks buffer (przechowywany w zmiennej) |
| Target | -The target variable to hold the returned data | +Target | +Zmienna docelowa, w której będą przechowywane zwrócone dane |
-
The above action block code sets the buffer read/write position to the start of the buffer and
- then reads back two pieces of data, storing them (as strings) in temporary local variables. These variables are then used to draw the data to the screen.
-
-
+
+
Powyższy kod bloku akcji ustawia pozycję odczytu/zapisu buffer na początek buffer, a następnie
+ a następnie odczytuje z powrotem dwie porcje danych, zapisując je (tak jak strings) w tymczasowych zmiennych lokalnych. Zmienne te są następnie używane do rysowania danych na ekranie.
+
+
-
Seek BufferThis action can be used to move (seek) to a position within a buffer. You supply the unique buffer ID value as returned by the action Create Buffer and then the offset value in bytes to move to. The offset value will be applied from the start of the buffer, so calling this function will move the read/write position to the start of the buffer then move the number of bytes given along and position the new read/write position there. However, if you flag the offset as relative, it will move the read/write position forward (or backwards if the offset is a negative value) from the current position.
--
Tej akcji można użyć do przesunięcia (szukania) do pozycji w witrynie buffer. Należy podać unikatową wartość identyfikacyjną buffer zwróconą przez akcję Utwórz bufor, a następnie wartość przesunięcia w bajtach, do której ma nastąpić przesunięcie. Wartość przesunięcia zostanie + zostanie zastosowana od początku strony buffer, więc wywołanie tej funkcji spowoduje przesunięcie pozycji odczytu/zapisu na początek strony buffer, a następnie przesunięcie o podaną liczbę bajtów i umieszczenie tam nowej pozycji odczytu/zapisu. Jeśli jednak oznaczysz + offset jako względny, spowoduje to przesunięcie pozycji odczytu/zapisu do przodu (lub do tyłu, jeśli offset jest wartością ujemną) od bieżącej pozycji.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Buffer | -The buffer index (stored in a variable) | +Buffer | +Indeks buffer (przechowywany w zmiennej) |
| offset | -The offset (in bytes) relative to the current seek position | +offset | +Przesunięcie (w bajtach) w stosunku do bieżącej pozycji wyszukiwania |
-
The above action block code gets the size of the buffer and then uses that value to set the read/write position to the end of the currently stored data.
-
-
+
+
Powyższy kod bloku akcji pobiera rozmiar strony buffer, a następnie wykorzystuje tę wartość do ustawienia pozycji odczytu/zapisu
+ na koniec aktualnie przechowywanych danych.
+
+
-
Write BufferThis action can be used to write data to a buffer. You supply the unique buffer ID to write to (as returned by the action Create Buffer) and then the value to write, which can be either a real or a string, but note that - all values are stored as strings so when you read from the buffer (using Read Buffer) you may need to use one of the Data Type Actions to convert it from a string - back to the original value. Keep in mind too that buffers are read and written to sequentially and so writing to a buffer will move the "seek" position along one, meaning that to write various pieces of data you simply call this action - the number of times required.
--
Tej akcji można użyć do zapisania danych na stronie buffer. Należy podać unikatowy identyfikator buffer, do którego ma zostać zapisany (zwrócony przez akcję Create Buffer), a następnie wartość do zapisania, która może być rzeczywista lub string, ale należy pamiętać, że + wszystkie wartości są przechowywane jako łańcuchy, więc podczas odczytu z buffer (za pomocą akcji Read Buffer) może być konieczne użycie jednej z akcji Data Type Actions w celu przekonwertowania wartości z łańcucha + z powrotem na oryginalną wartość. Należy także pamiętać, że strony buffers są odczytywane i zapisywane sekwencyjnie, a więc zapis na stronie buffer spowoduje przesunięcie pozycji "szukania" o jeden, co oznacza, że aby zapisać różne dane, wystarczy wywołać tę akcję + tyle razy, ile jest to wymagane.
++
| Argument | -Description | +Opis | |
|---|---|---|---|
| Buffer | -The buffer index (stored in a variable) | +Buffer | +Indeks buffer (przechowywany w zmiennej) |
| Value | -The value to add into the buffer | +Value | +Wartość, która ma być dodana do bufora |
-
The above action block code creates a global variable and then a buffer, assigning the unique
- buffer ID to the variable. This buffer than has two pieces of data written to it.
-
-
+
+
Powyższy kod bloku akcji tworzy zmienną globalną, a następnie buffer, przypisując do niej unikalny
+ buffer ID do zmiennej. Na stronie buffer zapisywane są następnie dwie porcje danych.
+
+
-
The Cameras library has actions that relate to setting the different variables associated with the camera view. A camera is a point in the room from which the room is viewed, and the camera view is what the camera sees (and what is drawn to the screen). These actions permit you to manipulate the different parts of the camera view and define areas of the room to show through the view position or view size as well as a few other basic functions.
The following actions are available:
-+
Strona Cameras Biblioteka Cameras zawiera akcje, które dotyczą ustawiania różnych zmiennych związanych z widokiem z kamery. Kamera to punkt w witrynie room, z którego jest oglądana strona room, a widok z kamery to co widzi kamera (i co jest rysowane na ekranie). Te działania umożliwiają manipulowanie różnymi częściami widoku z kamery oraz określanie obszarów strony room, które mają być pokazywane za pomocą pozycji widoku lub rozmiaru widoku, a także kilku innych podstawowych funkcji.
Dostępne są następujące działania:
+
 |
- Set View Variable | + |
+ Ustaw zmienną widoku |
 |
- Get View Variable | + |
+ Pobierz zmienną widoku |
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-
Get View VariableThis action permits you to get the value of certain built in variables related to a given view port. You select the view port variable to retrieve, then give the view port to target (from 0 to 7) and finally the target variable to hold the returned - value (this can be flagged as being a temporary local variable). The view port is the area of the screen that will be used to draw a given camera view (as set up in the room editor), and the different variables that you are able to get in this way - are outlined in the table below:
+Ta akcja umożliwia uzyskanie wartości pewnych wbudowanych zmiennych związanych z danym portem widoku. Wybierasz zmienną portu widoku, którą chcesz pobrać, następnie podajesz port widoku, do którego ma trafić zmienna (od 0 do 7) i zmienną docelową, która ma przechowywać zwróconą wartość (może być ona oznaczona jako tymczasowa zmienna lokalna). + wartość (może być oznaczona jako tymczasowa zmienna lokalna). Port widoku to obszar ekranu, który będzie używany do rysowania danego widoku z kamery (ustawionego w edytorze room ), a różne zmienne, które można uzyskać w ten sposób + przedstawiono w poniższej tabeli:
| Variable | -Description | +Zmienna | +Opis |
|---|---|---|---|
| Camera | -The value returned will be the unique ID value of the camera to assigned to the port (see here for more information). | +Zwracana wartość będzie unikatową wartością identyfikacyjną kamery, która ma być przypisana do portu (więcej informacji można znaleźć tutaj ). | |
| Visibility | -This will return a value of true or false where true is that the view port is visible (ie: it being drawn to the screen), and false meaning that nothing is being drawn. | +Spowoduje to zwrócenie wartości true lub false, gdzie true oznacza, że port widoku jest widoczny (tzn. jest rysowany na ekranie), a false oznacza, że nic nie jest rysowane. | |
| View Port X Coordinate | -This is the X position of the view port within the game window. | +Jest to pozycja X portu widoku w oknie gry. | |
| View Port Y Coordinate | -This is the Y position of the view port within the game window. | +Jest to pozycja Y portu widoku w oknie gry. | |
| View Port Width | -This is the width (in pixels) of the view port. | +Jest to szerokość (w pikselach) okna podglądu. | |
| View Port Height | -This is the height (in pixels) of the view port. | +Jest to wysokość (w pikselach) portu podglądu. | |
| View Port Surface ID | -This will return the unique ID value for the surface assigned to the view port or -1 if no surface has been assigned. | +Spowoduje to zwrócenie unikatowej wartości identyfikatora powierzchni przypisanej do portu widoku lub -1, jeśli nie przypisano żadnej powierzchni. |
-
+
| Argument | -Description | +Opis | |
|---|---|---|---|
| Variable | -The built in view variable to get | +Variable | +Wbudowana zmienna widoku, aby uzyskać |
| View | -The view port to target (from 0 - 7) | +View | +Port widoku, który ma być docelowy (od 0 do 7) |
| Target | -The target variable to hold the returned value (can be flagged as a temporary local variable) | +Target | +Zmienna docelowa, która ma przechowywać zwracaną wartość (może być oznaczona jako tymczasowa zmienna lokalna) |
-
The above action block code gets the current camera ID assigned to view
- port [0] and then checks to see if it is the same as the one stored in a global variable. If it is not, the camera is set to the new one.
-
-
+
+
Powyższy kod bloku akcji pobiera bieżący identyfikator kamery przypisany do widoku
+ port [0], a następnie sprawdza, czy jest on taki sam jak identyfikator zapisany w zmiennej globalnej. Jeśli nie, to kamera jest ustawiana na nowy identyfikator.
+
+
-
Set View VariableThis action permits you to set certain built in variables related to how the view port will display camera views of the room. You select the view port variable to edit, then give the view port to target (from 0 to 7) and finally the new value - for the variable. The view port is the area of the screen that will be used to draw a given camera view (as set up in the room editor), and the different variables that you are able to set in this way are outlined in the table below:
+Ta czynność umożliwia ustawienie pewnych wbudowanych zmiennych związanych z wyświetlaniem przez port widokowy wid oku z kamery na stronie room. Wybierz zmienną portu widokowego do edycji, następnie podaj port widokowy jako cel (od 0 do 7), a na końcu nową wartość + dla zmiennej. Port widoku to obszar ekranu, który będzie używany do rysowania danego widoku z kamery (zgodnie z ustawieniami w edytorze room ), a różne zmienne, które można ustawić w ten sposób, przedstawiono w poniższej tabeli:
| Variable | -Description | +Zmienna | +Opis |
|---|---|---|---|
| Camera | -This is for setting the viewport to show a different Camera View. You need to supply the unique ID value of the camera to change to (see here for - more information). | +Służy do ustawienia rzutni tak, aby pokazywała inny widok z kamery. Należy podać unikatową wartość ID kamery, na którą ma zostać zmieniony widok (więcej informacji na ten temat można znaleźć tutaj + więcej informacji). | |
| Visibility | -This is the visibility toggle for the view port and expects a value of true or false where setting it to true will make the view port visible (ie: it will draw to the screen), and a value of false will not draw - anything to the screen. | +Jest to przełącznik widoczności portu widoku i oczekuje wartości true lub false, gdzie ustawienie wartości true spowoduje, że port widoku będzie widoczny (tzn. będzie rysował na ekranie), a wartość false nie spowoduje rysowania + niczego na ekranie. | |
| View Port X Coordinate | -This is the X position of the view port within the game window. Note though that is is only really required when more than one view port is active - for example to create a split screen effect - and if used when only one port is active you get - unexpected results. | +Jest to pozycja X portu widoku w oknie gry. Zauważ jednak, że jest ona wymagana tylko wtedy, gdy aktywny jest więcej niż jeden port widoku - na przykład w celu utworzenia efektu podzielonego ekranu - a jeśli zostanie użyta, gdy aktywny jest tylko jeden port, uzyskasz + nieoczekiwane rezultaty. | |
| View Port Y Coordinate | -This is the Y position of the view port within the game window. Note though that is is only really required when more than one view port is active - for example to create a split screen effect - and if used when only one port is active you get - unexpected results. | +Jest to pozycja Y portu widoku w oknie gry. Zauważ jednak, że jest ona wymagana tylko wtedy, gdy aktywny jest więcej niż jeden port widoku - na przykład w celu utworzenia efektu podzielonego ekranu - a jeśli zostanie użyta, gdy aktywny jest tylko jeden port, uzyskasz + nieoczekiwane rezultaty. | |
| View Port Width | -This is the width (in pixels) of the view port. The width of the view port (or combined view ports if more than one are active) define the width of the game window or background canvas at the start of the game, so changing this value after the - game has started will have no visible effect on the game window size unless called along with the GML function window_set_size(). - Also note that if you have a larger or smaller port size than that assigned to the camera, then the camera view will be scaled down - or up - to fit. | +Jest to szerokość (w pikselach) portu widoku. Szerokość portu widoku (lub połączonych portów widoku, jeśli aktywnych jest więcej niż jeden) określa szerokość okna gry lub tła na początku gry, więc zmiana tej wartości po + po rozpoczęciu gry nie będzie miała widocznego wpływu na rozmiar okna gry, chyba że zostanie wywołana razem z funkcją GML window_set_size(). + Należy również pamiętać, że jeśli rozmiar portu jest większy lub mniejszy niż rozmiar przypisany do kamery, widok z kamery zostanie przeskalowany w dół lub w górę, aby go dopasować. | |
| View Port Height | -This is the height (in pixels) of the view port. The height of the view port (or combined view ports if more than one are active) define the height of the game window or background canvas at the start of the game, so changing this value after - the game has started will have no visible effect on the game window size unless called along with the GML function window_set_size(). - Also note that if you have a larger or smaller port size than that assigned to the camera view, then the camera view will be scaled down - or up - to fit. | +Jest to wysokość (w pikselach) portu widoku. Wysokość portu widoku (lub połączonych portów widoku, jeśli aktywnych jest więcej niż jeden) określa wysokość okna gry lub tła obrazu na początku gry, więc zmiana tej wartości po + po rozpoczęciu gry nie będzie miała widocznego wpływu na rozmiar okna gry, chyba że zostanie wywołana razem z funkcją GML window_set_size(). + Należy również pamiętać, że jeśli rozmiar portu jest większy lub mniejszy niż rozmiar przypisany do widoku z kamery, to widok z kamery zostanie przeskalowany w dół lub w górę, aby go dopasować. | |
| View Port Surface ID | -With this variable you can set the contents of a given view port to draw to a surface, with the value you supply being that of the surface to use for drawing the view port to. For more information please see here. | +Za pomocą tej zmiennej można ustawić, aby zawartość danego okna podglądu była rysowana na powierzchni, przy czym wartość podawana przez użytkownika jest wartością powierzchni, na którą ma być rysowane okno podglądu. Więcej informacji na ten temat można znaleźć tutaj. |
-
+
+
| Argument | -Description | +Opis | |
|---|---|---|---|
| Variable | -The built in view variable to set | +Variable | +Wbudowana zmienna widoku do ustawiania |
| View | -The view port to target (from 0 - 7) | +View | +Port widoku, który ma być docelowy (od 0 do 7) |
| Value | -The new value for the built in variable | +Value | +Nowa wartość dla wbudowanej zmiennej |
-
The above action block code will check for a key press and if one is detected it will
- make the view port [0] visible, otherwise it will make it invisible.
-
-
+
+
Powyższy kod bloku akcji sprawdzi, czy został naciśnięty klawisz i jeśli zostanie wykryty, to
+ sprawi, że port widokowy [0] stanie się widoczny, w przeciwnym razie będzie niewidoczny.
+
+
-
When planning motions or deciding on certain actions, it is often important to see whether there are collisions with other objects at certain places within the game world, and often choosing the right collision for the job is the most important task of all. GameMaker has a number of actions to help you deal with collisions correctly and in accordance with the needs of your project:
+Podczas planowania ruchów lub podejmowania decyzji o wykonaniu pewnych czynności często ważne jest sprawdzenie, czy w określonych miejscach w świecie gry występują kolizje z innymi stronami objects, a często wybór odpowiedniej kolizji jest najważniejszym zadaniem. GameMaker posiada wiele funkcji, które pomagają w prawidłowym radzeniu sobie z kolizjami, zgodnie z potrzebami projektu:
 |
- If Any Object At Place | +If Any Object At Place |
 |
- If Object At Place | +Jeśli Object w miejscu |
 |
- If Collision Shape | +Jeśli kształt kolizji |
 |
- If Collision Point | +Jeśli punkt kolizji |
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-
If Any Object At PlaceThis action is used to check and see if there is an instance of any object placed at a position based on the collision mask of the calling instance. You give the position, which can be an absolute position or a position relative to the instance, - and the action will return true if there is a collision or false if there is not. You can also check the "Not" flag to check if there is not a collision at the given position, and the action will then return true if no collisions are found and false otherwise. Collisions are calculated based on the collision mask of the calling instance overlapping the collision mask of any instance at the position (as if it was being "placed" at the position).
-IMPORTANT! Collisions will only register for those instances that have a valid collision mask, ie: they have a sprite assigned to the sprite_index, or a sprite assigned to the mask_index. If either of the instances in - the collision have no collision mask then the collision will not be detected, regardless of what the instance is drawing at the time.
-Note that to add actions into an "if" block, they should be dropped to the side of the action, as shown in the image below:
+Ta akcja służy do sprawdzania, czy istnieje instancja dowolnej strony object umieszczona w pozycji opartej na masce kolizji instancji wywołującej. Podajesz pozycję, która może być pozycją bezwzględną lub pozycją względną względem instancji, + a akcja zwróci true, jeśli kolizja wystąpiła, lub false, jeśli nie wystąpiła. Możesz także zaznaczyć pole "Not" flag, aby sprawdzić, czy w podanej pozycji nie ma kolizji, a akcja zwróci wtedy true, jeśli nie znaleziono kolizji, lub false w przeciwnym wypadku. Kolizje są obliczane na podstawie tego, że maska kolizji wywoływanej instancji pokrywa się z maską kolizji dowolnej instancji znajdującej się na danej pozycji (tak jakby była ona "umieszczana" na tej pozycji).
+WAŻNE! Kolizje będą rejestrowane tylko dla tych instancji, które mają poprawną maskę kolizji, tzn. mają sprite przypisaną do sprite_index, lub sprite przypisaną do mask_index. Jeśli któraś z instancji w + kolizji nie ma maski kolizji, to kolizja nie zostanie wykryta, niezależnie od tego, co dana instancja rysuje w danym momencie.
+Należy pamiętać, że aby dodać akcje do bloku "if", należy je upuścić z boku akcji, jak pokazano na poniższym rysunku:
+
+
-
| Argument | -Description | +Opis | |
|---|---|---|---|
| x | -The x position to check | +x | +Pozycja x do sprawdzenia |
| y | -The y position to check | +y | +Pozycja y do sprawdzenia |
-
The above action block code checks for a collision at the position where the instance
- is placed and if one is found it blends the instance with red, otherwise it leaves the blending as normal (white).
-
-
+
+
Powyższy kod bloku akcji sprawdza, czy w miejscu, w którym znajduje się instancja, nie ma kolizji.
+ i jeśli zostanie znaleziona, miesza instancję z kolorem czerwonym, a w przeciwnym razie pozostawia mieszanie jako normalne (białe).
+
+
-
If Collision PointThis action is used to check and see if there is a collision with one or more instances of the given object(s) at a specific point in the room and will evaluate to true if a collision is detected, or false otherwise. You give the object to check for and the position to check at - which can be an absolute position in the room or a position relative to the instance - and you can also check the Not flag to check if there is not a collision at the given position, meaning that the action will then only evaluate as true if no collisions are found, otherwise it will evaluate as false. You can also set the Exclude Self option to exclude the calling instance from the collision check.
-Next you can check/uncheck the option to Return List. Checking this means the action will create and populate a list data structure with all instances in collision with the point and set the Target variable to the DS list ID. When unchecked, it will only set the Target variable to a value less than 0 when no collision is detected, or the unique ID value of one of the instances in the collision (note that if multiple instances are in collision then you have no way of knowing which instance ID will be returned when not using a list).
-If you have selected to return a list - and the Target variable is not set to Temp - then you can also select the Free Target option. When set to true, then the list contained in the target variable will be destroyed and a new list created (and returned to the target variable) each time you call the action. In this way you can re-use the same variable without worrying about memory leaks, as, if you do not check Free Target option, you become responsible for destroying the list before using the variable again in the action. Note that regardless of whether this option is checked or not, if you have set the action to Return List, then the target variable will always contain a list ID, and as such, this will need to be freed when the instance is destroyed or the room ends (you can use the Clean Up event for this, for example, along with the Free Data Structure action). It is worth noting that you can set the Free Target option to use a pre-defined variable or an expression and so control when the list data structure is freed by setting the variable elsewhere (or having different outcomes for the expression) as long as it evaluates to true/false.
-Finally, you supply the Target variable that you want to hold the returned value or list ID. If you flag the Target variable to hold the returned value as being a Temp (local) variable, then the action will create this variable to hold the return value only until the end of the event, in this case the Free Target option does nothing and you will be responsible for destroying the DS list if that option has been checked. If no target variable is supplied and the Return List option is checked, no list will be created.
-IMPORTANT! Collisions will only register for those instances that have a valid collision mask, ie: they have a sprite assigned to the sprite_index, or a sprite assigned to the mask_index. If the instances of the object being checked for in this action have no collision mask then the collision will not be detected, regardless of what the instance is drawing at the time.
-Note that to add actions into an "if" block, they should be dropped to the side of the action, as shown in the image below:
+Ta akcja jest używana do sprawdzania, czy w określonym miejscu na stronie object występuje kolizja z jedną lub kilkoma instancjami danego obiektu room. W przypadku wykrycia kolizji akcja przyjmuje wartość true, a w przeciwnym razie false. Użytkownik podaje obiekt + który ma być sprawdzany, oraz pozycję, w której ma być sprawdzany - może to być pozycja bezwzględna w room lub pozycja względem instancji - i możesz także sprawdzić Not flag, aby sprawdzić, czy w podanej pozycji nie ma kolizji, co oznacza, że + że działanie zostanie ocenione jako true tylko wtedy, gdy nie zostaną znalezione żadne kolizje, w przeciwnym razie zostanie ocenione jako false. Możesz także ustawić opcję Wyklucz siebie, aby wykluczyć instancję wywołującą ze sprawdzania kolizji.
+Następnie możesz zaznaczyć/odznaczyć opcję Zwróć listę. Zaznaczenie tej opcji oznacza, że akcja utworzy i zapełni strukturę danych Lista wszystkimi instancjami w kolizji z punktem i ustawi zmienną Cel na identyfikator listy DS. + z punktem i ustawi zmienną Target na identyfikator listy DS. Jeśli nie jest zaznaczone, zmienna Target będzie miała wartość mniejszą od 0 tylko wtedy, gdy nie zostanie wykryta żadna kolizja, lub będzie miała unikatową wartość ID jednej z instancji w kolizji + (zauważ, że jeśli w kolizji bierze udział wiele instancji, to nie wiadomo, który identyfikator instancji zostanie zwrócony, jeśli nie używa się listy).
+Jeśli wybrano opcję zwracania listy, a zmienna Target nie jest ustawiona na Temp, można również wybrać opcję Free Tar get. Jeśli ustawisz ją na true, wówczas lista zawarta w zmiennej docelowej zostanie zniszczona, a + a nowa lista będzie tworzona (i zwracana do zmiennej docelowej) przy każdym wywołaniu akcji. W ten sposób można ponownie używać tej samej zmiennej bez obawy o wycieki pamięci, ponieważ jeśli nie zaznaczymy opcji Free Target, to stajemy się odpowiedzialni + za zniszczenie listy przed ponownym użyciem zmiennej w akcji. Zauważ, że niezależnie od tego, czy opcja ta jest zaznaczona, czy nie, jeśli akcja została ustawiona na Zwróć listę, to zmienna docelowa zawsze będzie zawierać identyfikator listy, + i jako taka będzie musiała zostać zwolniona, gdy instancja zostanie zniszczona lub gdy zakończy się działanie strony room (możesz do tego użyć zdarzenia Clean Up, na przykład wraz z akcją Free Data Structure ). + Warto zauważyć, że można ustawić opcję Free Target tak, aby używała predefiniowanej zmiennej lub wyrażenia i w ten sposób kontrolować, kiedy struktura danych listy zostanie zwolniona, ustawiając zmienną w innym miejscu (lub mając różne wyniki dla wyrażenia) + tak długo, jak będzie ono odpowiadać true/false.
+Na koniec należy podać zmienną docelową, która ma przechowywać zwróconą wartość lub identyfikator listy. Jeśli flag zmienna docelowa, która ma przechowywać wartość zwracaną, jest zmienną Temp (lokalną), to akcja utworzy tę zmienną, aby przechowywać wartość zwracaną tylko do końca zdarzenia. + W tym przypadku opcja Free Target nie robi nic, a użytkownik będzie odpowiedzialny za zniszczenie listy DS, jeśli opcja ta została zaznaczona. Jeśli nie podano zmiennej docelowej i zaznaczono opcję Lista zwracana, lista nie zostanie utworzona.
+WAŻNE! Kolizje będą rejestrowane tylko dla tych instancji, które mają poprawną maskę kolizji, tzn. mają sprite przypisaną do sprite_index, lub sprite przypisaną do mask_index. Jeśli instancje object sprawdzane w tej akcji nie mają maski kolizji, to nie zostaną wykryte, niezależnie od tego, co w danej chwili rysuje instancja. + sprawdzane w tej akcji nie mają maski kolizji, to kolizja nie zostanie wykryta, niezależnie od tego, co dana instancja rysuje w danym momencie.
+Należy pamiętać, że aby dodać akcje do bloku "if", należy je upuścić z boku akcji, jak pokazano na poniższym rysunku:
+
+
-
| Argument | -Description | +Opis | |
|---|---|---|---|
| Object | -The object or instance to check for collisions. You can click the  icon to add multiple objects to check collisions with. |
+ Shape | +Kształt, którego należy użyć |
| x | -The x position to check | +Object | +object, aby sprawdzić, czy nie występują przypadki |
| y | -The y position to check | +x1 | +Pozycja x, od której należy rozpocząć pracę |
| Exclude Self | -Whether the collision checker should ignore the current instance or not | +y1 | +Pozycja y, od której ma rozpocząć się praca |
| Not | -Used to invert the condition; only satisfies if a collision is not found | +x2 | +Pozycja x, na której ma się zakończyć |
| Return List | -Whether a list of collisions should be returned in Target, or only the first collision | +y2 | +Pozycja y, na której ma się zakończyć |
| Free Target | -Can be set to a variable or expression, or set to true/false to control freeing of the list memory when re-using a list variable | +Free Target | +Może być ustawiona na zmienną lub wyrażenie, albo na true/false, aby kontrolować zwalnianie pamięci listy przy ponownym użyciu zmiennej listy |
| Target | -The variable to target for the return value of the action | +Target | +Zmienna, która ma być docelową wartością zwracaną przez akcję |
-
The above action block code checks for a collision at the mouse x/y position with an instance of the object "obj_Enemy". If one (or more) collisions is found, an effect is created and at the position of the instance with the ID stored in the Target variable, and then the instance is destroyed. If no collision is found, a different effect is created at the mouse position.
-
-
+
+
Powyższy kod bloku akcji sprawdza, czy w położeniu x/y myszy nie wystąpiła kolizja z instancją
+ object "obj_Enemy". Jeśli zostanie znaleziona jedna (lub więcej) kolizja, tworzony jest efekt na pozycji instancji o identyfikatorze zapisanym w zmiennej Target, a następnie instancja jest niszczona. Jeśli nie zostanie znaleziona żadna kolizja, w pozycji myszy zostanie utworzony inny
+ efekt zostanie utworzony w miejscu, w którym znajduje się mysz.
+
+
-
If Collision ShapeThis action is used to check and see if there is a collision with an instance of the given object(s) within a given shaped area or along a line. You give the shape (rectangle, ellipse or line), the object to check for, and then supply the coordinates for the upper-left and lower-right corners of the shape being used, or in the case of a line, the start and end positions. These can be absolute positions within the game room, or positions relative to the instance performing the action. You can see how this works in the image below:
-
As you can see, the results will depend on the collision mask of the instance being checked for, meaning the instance of the object you are looking for must have a sprite assigned to the sprite_index, or a sprite assigned to the mask_index. If it does not then it will not be detected by these functions, regardless of whether it is drawing a sprite or not. It is worth noting that any instance that falls completely within the boundaries set for the ellipse or rectangle shape will also return a collision. The action will evaluate to true if a collision is detected, or false otherwise, although you can also check the Not flag to check if there is not a collision with the given shaped area, and the action will then only evaluate as true if no collisions are found, otherwise it will evaluate as false. You can also set the Exclude Self option to exclude the calling instance from the collision check.
Next you can check/uncheck the option to Return List. Checking this means the action will create and populate a list data structure with allinstances in collision with the shape and set the Target variable to the DS list ID. When unchecked, it will only set the Target variable to a value less than 0 when no collision is detected, or the unique ID value of one of the instances in the collision (note that if multiple instances are in collision then you have no way of knowing which instance ID will be returned when not using a list).
-If you have selected to return a list - and the Target variable is not set to Temp - then you can also select the Free Target option. When set to true, then the list contained in the target variable will be destroyed and a new list created (and returned to the target variable) each time you call the action. In this way you can re-use the same variable without worrying about memory leaks, as, if you do not check Free Target option, you become responsible for destroying the list before using the variable again in the action. Note that regardless of whether this option is checked or not, if you have set the action to Return List, then the target variable will always contain a list ID, and as such, this will need to be freed when the instance is destroyed or the room ends (you can use the Clean Up event for this, for example, along with the Free Data Structure action). It is worth noting that you can set the Free Target option to use a pre-defined variable or an expression and so control when the list data structure is freed by setting the variable elsewhere (or having different outcomes for the expression) as long as it evaluates to true/false.
-Finally, you supply the Target variable that you want to hold the returned value or list ID. If you flag the Target variable to hold the returned value as being a Temp (local) variable, then the action will create this variable to hold the return value only until the end of the event, in this case the Free Target option does nothing and you will be responsible for destroying the DS list if that option has been checked. If no target variable is supplied and the Return List option is checked, no list will be created.
-IMPORTANT! Collisions will only register for those instances that have a valid collision mask, ie: they have a sprite assigned to the sprite_index, or a sprite assigned to the mask_index. If the instances of the object being checked for in this action have no collision mask then the collision will not be detected, regardless of what the instance is drawing at the time.
-Note that to add actions into an "if" block, they should be dropped to the side of the action, as shown in the image below:
-
-
Ta akcja służy do sprawdzania, czy w obszarze o określonym kształcie lub wzdłuż linii nie doszło do kolizji z instancją danej strony object. Podajesz kształt (prostokąt, elipsę lub linię), adres object, który ma zostać sprawdzony, a następnie podajesz współrzędne + górnego lewego i dolnego prawego rogu używanego kształtu lub, w przypadku linii, pozycji początkowej i końcowej. Mogą to być pozycje bezwzględne w grze room lub pozycje względne w stosunku do instancji wykonującej działanie. Możesz zobaczyć, jak + jak to działa, można zobaczyć na poniższym obrazku:
+Jak widać, wyniki będą zależały od maski kolizji sprawdzanej instancji.
+ co oznacza, że szukana instancja object musi mieć sprite przypisaną do sprite_index, lub sprite przypisaną do mask_index. Jeśli tak nie jest, to nie zostanie wykryta przez te funkcje,
+ niezależnie od tego, czy rysuje stronę sprite czy nie. Warto zauważyć, że każda instancja, która całkowicie mieści się w granicach określonych dla kształtu elipsy lub prostokąta, również zwróci kolizję. Działanie zostanie ocenione na true, jeśli
+ zostanie wykryta kolizja, lub false w przeciwnym razie, choć można również sprawdzić Not flag, aby sprawdzić, czy nie ma kolizji z obszarem o podanym kształcie, a działanie zostanie ocenione jako true tylko wtedy, gdy nie znaleziono kolizji.
+ w przeciwnym razie będzie to false. Możesz także ustawić opcję Wyklucz siebie, aby wykluczyć instancję wywołującą ze sprawdzania kolizji.
Następnie można zaznaczyć lub odznaczyć opcję Zwróć listę. Zaznaczenie tej opcji spowoduje, że akcja utworzy i zapełni listę strukturą danych zawierającą wszystkie instancjekolidujące + z kształtem i ustawi zmienną Target na identyfikator listy DS. Jeśli nie jest zaznaczone, zmienna Target będzie miała wartość mniejszą od 0 tylko wtedy, gdy nie zostanie wykryta żadna kolizja, lub będzie miała unikatową wartość ID jednej z instancji w kolizji + (zauważ, że jeśli w kolizji bierze udział wiele instancji, to nie wiadomo, który identyfikator instancji zostanie zwrócony, jeśli nie używa się listy).
+Jeśli wybrano opcję zwracania listy, a zmienna Target nie jest ustawiona na Temp, można również wybrać opcję Free Tar get. Po ustawieniu na true, lista zawarta w zmiennej docelowej zostanie zniszczona i + a nowa lista będzie tworzona (i zwracana do zmiennej docelowej) przy każdym wywołaniu akcji. W ten sposób można ponownie używać tej samej zmiennej bez obawy o wycieki pamięci, ponieważ jeśli nie zaznaczymy opcji Free Target, to stajemy się odpowiedzialni + za zniszczenie listy przed ponownym użyciem zmiennej w akcji. Zauważ, że niezależnie od tego, czy ta opcja jest zaznaczona, czy nie, jeśli akcja została ustawiona na Zwróć listę, to zmienna docelowa zawsze będzie zawierać identyfikator listy, + i jako taka będzie musiała zostać zwolniona, gdy instancja zostanie zniszczona lub gdy zakończy się działanie room (możesz do tego celu użyć np. zdarzenia Sprzątanie na przykład wraz z akcją Free Data Structure ). + Warto zauważyć, że można ustawić opcję Free Target tak, by używała predefiniowanej zmiennej lub wyrażenia i w ten sposób kontrolować, kiedy struktura danych listy zostanie zwolniona, ustawiając zmienną w innym miejscu (lub mając różne wyniki dla wyrażenia) + tak długo, jak będzie ono odpowiadać true/false.
+Na koniec należy podać zmienną docelową, która ma przechowywać zwróconą wartość lub identyfikator listy. Jeśli flag zmienna docelowa, która ma przechowywać wartość zwracaną, jest zmienną Temp (lokalną), to akcja utworzy tę zmienną, aby przechowywać wartość zwracaną tylko do końca zdarzenia. + W tym przypadku opcja Free Target nie robi nic, a użytkownik będzie odpowiedzialny za zniszczenie listy DS, jeśli opcja ta została zaznaczona. Jeśli nie podano zmiennej docelowej i zaznaczono opcję Lista zwracana, lista nie zostanie utworzona.
+WAŻNE! Kolizje będą rejestrowane tylko dla tych instancji, które mają poprawną maskę kolizji, tzn. mają sprite przypisaną do sprite_index, lub sprite przypisaną do mask_index. Jeśli instancje object sprawdzane w tej akcji nie mają maski kolizji, to nie zostaną wykryte, niezależnie od tego, co w danej chwili rysuje instancja. + sprawdzane w tej akcji nie mają maski kolizji, to kolizja nie zostanie wykryta, niezależnie od tego, co dana instancja rysuje w danym momencie.
+Należy pamiętać, że aby dodać akcje do bloku "if", należy je upuścić z boku akcji, jak pokazano na poniższym rysunku:
+
+
| Argument | -Description | +Opis | |
|---|---|---|---|
| Shape | -The shape to use | +Shape | +Kształt, którego należy użyć |
| Object | -The object or instance to check for collisions. You can click the icon to add multiple objects to check collisions with. |
+ Object | +object, aby sprawdzić, czy nie występują przypadki |
| x1 | -The x position to start from | +x1 | +Pozycja x, od której należy rozpocząć pracę |
| y1 | -The y position to start from | +y1 | +Pozycja y, od której ma rozpocząć się praca |
| x2 | -The x position to end at | +x2 | +Pozycja x, na której ma się zakończyć |
| y2 | -The y position to end at | +y2 | +Pozycja y, na której ma się zakończyć |
| Exclude Self | -Whether the collision checker should ignore the current instance or not | +Free Target | +Może być ustawiona na zmienną lub wyrażenie, albo na true/false, aby kontrolować zwalnianie pamięci listy przy ponownym użyciu zmiennej listy |
| Not | -Used to invert the condition; only satisfies if a collision is not found | -||
| Return List | -Whether a list of collisions should be returned in Target, or only the first collision | -||
| Free Target | -Can be set to a variable or expression, or set to true/false to control freeing of the list memory when re-using a list variable | -||
| Target | -The variable to target for the return value of the action | +Target | +Zmienna, która ma być docelową wartością zwracaną przez akcję |
-
The above action block code checks for a collision with any instances of the object " obj_Enemy" within a 100px circle around the calling instances position. The action generates a list of all instances found to be in collision and stores the list ID in the Target variable. If the action evaluates to true then the list is looped through and each instance with its ID stored in the list has its "hp" variable reduced by 1. The DS list is then freed.
-
-
+
+
Powyższy kod bloku akcji sprawdza, czy nie doszło do kolizji z dowolnymi instancjami object "
+ obj_Enemy" w promieniu 100px wokół pozycji instancji wywołującej. Akcja generuje listę wszystkich instancji, które zostały uznane za kolizyjne, i zapisuje jej identyfikator w zmiennej Target. Jeśli działanie zakończy się wynikiem
+ true to lista jest zapętlana i każdej instancji o ID zapisanym na liście zmniejszana jest zmienna "hp" o 1. Następnie lista DS jest zwalniana.
+
+
-
If Object At PlaceThis action is used to check and see if there is a collision with one or more instances of the given object(s) with the current instance placed at a point in the room, based on the collision mask of the calling instance. The action will evaluate to true if a collision is detected, or false otherwise.
-You give the object to check for and the position to "place" the instance to perform the check - which can be an absolute position in the room or a position relative to the instance - and you can also check the Not flag to check if there is not a collision at the given position, in which case the action will then only evaluate as true if no collisions are found, otherwise it will evaluate as false.
-After giving the object and position, you can check/uncheck the option to Return List. Checking this means the action will create and populate a list data structure with all instances in collision with the instance and set the Target variable to the DS list ID. When unchecked, it will only set the Target variable to a value less than 0 when no collision is detected, or the unique ID value of one of the instances in the collision (note that if multiple instances are in collision then you have no way of knowing which instance ID will be returned when not using a list).
-If you have selected to return a list - and the Target variable is not set to Temp - then you can also select the Free Target option. When set to true, then the list contained in the target variable will be destroyed and a new list created (and returned to the target variable) each time you call the action. In this way you can re-use the same variable without worrying about memory leaks, as, if you do not check Free Target option, you become responsible for destroying the list before using the variable again in the action. Note that regardless of whether this option is checked or not, if you have set the action to Return List, then the target variable will always contain a list ID, and as such, this will need to be freed when the instance is destroyed or the room ends (you can use the Clean Up event for this, for example, along with the Free Data Structure action). It is worth noting that you can set the Free Target option to use a pre-defined variable or an expression and so control when the list data structure is freed by setting the variable elsewhere (or having different outcomes for the expression) as long as it evaluates to true/false.
-Finally, you supply the Target variable that you want to hold the returned value or list ID. If you flag the Target variable to hold the returned value as being a Temp (local) variable, then the action will create this variable to hold the return value only until the end of the event, in this case the Free Target option does nothing and you will be responsible for destroying the DS list if that option has been checked. If no target variable is supplied and the Return List option is checked, no list will be created.
-IMPORTANT! Collisions will only register for those instances that have a valid collision mask, i.e. they have a sprite assigned to the sprite_index, or a sprite assigned to the mask_index. If either of the instances in the collision have no collision mask then the collision will not be detected, regardless of what the instance is drawing at the time.
-Note that to add actions into an "if" block, they should be dropped to the side of the action, as shown in the image below:
+Ta akcja służy do sprawdzania, czy istnieje kolizja z jedną lub wieloma instancjami danej strony object, przy czym bieżąca instancja jest umieszczona w punkcie na stronie room, na podstawie maski kolizji instancji wywołującej. W przypadku wykrycia kolizji akcja zwraca wartość true, a w przeciwnym razie false. Podajesz adres object do sprawdzenia i pozycję, w której instancja ma zostać umieszczona w celu sprawdzenia - może to być pozycja bezwzględna w room lub pozycja względna względem instancji. + - Możesz także sprawdzić Not flag, aby sprawdzić, czy w podanej pozycji nie ma kolizji, w którym to przypadku akcja zostanie oceniona jako true tylko wtedy, gdy nie znaleziono kolizji, a w przeciwnym razie jako false.
+Po podaniu adresu object i pozycji można zaznaczyć/odznaczyć opcję Zwróć listę. Zaznaczenie tej opcji oznacza, że akcja utworzy i zapełni strukturę danych listą + wszystkimi instancjami będącymi w kolizji z daną instancją i ustawi zmienną docelową na identyfikator listy DS. Gdy nie jest zaznaczona, ustawi zmienną Target na wartość mniejszą od 0 tylko wtedy, gdy nie zostanie wykryta żadna kolizja, lub na unikatową wartość ID jednej z instancji w kolizji (zauważ, że jeśli w kolizji bierze udział wiele instancji, nie masz możliwości sprawdzenia, które ID instancji zostanie zwrócone, jeśli nie używasz listy).
+Jeśli wybrano opcję zwracania listy, a zmienna Target nie jest ustawiona na Temp, można również wybrać opcję Free Tar get. Po ustawieniu na true, lista zawarta w zmiennej docelowej zostanie zniszczona i + a nowa lista będzie tworzona (i zwracana do zmiennej docelowej) przy każdym wywołaniu akcji. W ten sposób można ponownie używać tej samej zmiennej bez obawy o wycieki pamięci, ponieważ jeśli nie zaznaczymy opcji Free Target, to stajemy się odpowiedzialni + za zniszczenie listy przed ponownym użyciem zmiennej w akcji. Zauważ, że niezależnie od tego, czy opcja ta jest zaznaczona, czy nie, jeśli akcja została ustawiona na Zwróć listę, to zmienna docelowa zawsze będzie zawierać identyfikator listy, + i jako taka będzie musiała zostać zwolniona, gdy instancja zostanie zniszczona lub gdy zakończy się działanie room (możesz do tego celu użyć np. zdarzenia Sprzątanie na przykład wraz z akcją Free Data Structure ). + Warto zauważyć, że można ustawić opcję Free Target tak, by używała predefiniowanej zmiennej lub wyrażenia i w ten sposób kontrolować, kiedy struktura danych listy zostanie zwolniona, ustawiając zmienną w innym miejscu (lub mając różne wyniki dla wyrażenia) + tak długo, jak będzie ono odpowiadać true/false.
+Na koniec należy podać zmienną docelową, która ma przechowywać wartość zwracaną lub identyfikator listy. Jeśli flag zmienna docelowa, która ma przechowywać wartość zwracaną, jest zmienną Temp (lokalną), to akcja utworzy tę zmienną, aby przechowywać wartość zwracaną tylko do końca zdarzenia. + W tym przypadku opcja Free Target nie robi nic, a użytkownik będzie odpowiedzialny za zniszczenie listy DS, jeśli opcja ta została zaznaczona. Jeśli nie podano zmiennej docelowej i zaznaczono opcję Lista zwracana, lista nie zostanie utworzona.
+WAŻNE! Kolizje będą rejestrowane tylko dla tych instancji, które mają poprawną maskę kolizji, tzn. mają sprite przypisaną do sprite_index, lub sprite przypisaną do mask_index. Jeśli któraś z instancji w + kolizji nie ma maski kolizji, to kolizja nie zostanie wykryta, niezależnie od tego, co dana instancja rysuje w danym momencie.
+Należy pamiętać, że aby dodać akcje do bloku "if", należy je upuścić z boku akcji, jak pokazano na poniższym rysunku:
+
+
-
| Argument | -Description | +Opis | |
|---|---|---|---|
| Object | -The object or instance to check for collisions. You can click the icon to add multiple objects to check collisions with. |
+ Object | +object, aby sprawdzić, czy nie występują przypadki |
| X | -The x position to check | +x | +Pozycja x do sprawdzenia |
| Y | -The y position to check | +y | +Pozycja y do sprawdzenia |
| Not | -Used to invert the condition; only satisfies if a collision is not found | +Free Target | +Może być ustawiona na zmienną lub wyrażenie, albo na true/false, aby kontrolować zwalnianie pamięci listy przy ponownym użyciu zmiennej listy |
| Return List | -Whether a list of collisions should be returned in Target, or only the first collision | -||
| Free Target | -Can be set to a variable or expression, or set to true/false to control freeing of the list memory when re-using a list variable | -||
| Target | -The variable to target for the return value of the action | +Target | +Zmienna, która ma być docelową wartością zwracaną przez akcję |
-
The above action block code checks for a collision with any instances of the object "obj_Wall" to the left and to the right and if one is found it reverses the horizontal direction of the calling instance.
-
-
+
+
Powyższy kod bloku akcji sprawdza, czy nie wystąpiła kolizja z instancjami object "
+ obj_Wall" po lewej i po prawej stronie, a jeśli taka kolizja zostanie znaleziona, odwraca kierunek poziomy instancji wywołującej.
+
+
-
Apply To...This action can be used to change the Action Scope for all further actions to chained to this one. Like with an if action, if you drop further - actions to the right of the Apply to... action then they will be run from the scoped object or instance. The scope is chosen from the pop up menu shown when you click the small arrow at the top right of the action, and in this way you can tell - a different set of objects - or even a single instance if you have the instance ID - to run multiple actions before continuing with the code of the current object.
-Note that to add actions into the "Applies To" block, they should be dropped to the side of the action, as shown in the image below:
-
These actions will now be run from the object or instance that is being targeted by the
- "Applies To" block, while any actions dropped elsewhere will be performed after the "Applies To" block.
-
The above action block code checks a variable to see if it equals 100 and if it does it changes scope
- to the " obj_Player" instances and tells them to run the Set Sprite action (all instances of this object in the room will change sprite at this point), before continuing
- to add 1 onto the variable within the instance running the full code block.
-
-
+
Tej akcji można użyć do zmiany zakresu akcji dla wszystkich kolejnych akcji, które są do niej dołączone. Podobnie jak w przypadku if jeśli umieścisz kolejne akcje + kolejne akcje na prawo od akcji Zastosuj do..., będą one uruchamiane z zakresu object lub instancji. Zakres wybiera się z menu podręcznego, które pojawia się po kliknięciu małej strzałki w prawym górnym rogu akcji. + różnych zestawów objects - lub nawet jednej instancji, jeśli masz identyfikator instancji - aby uruchamiać wiele akcji przed kontynuowaniem kodu bieżącej object.
+Należy pamiętać, że aby dodać akcje do bloku "Dotyczy", należy je upuścić z boku akcji, jak pokazano na poniższej ilustracji:
+Działania te będą teraz uruchamiane ze strony object lub instancji, do której odnosi się blok
+ "Stosuje się do", podczas gdy wszelkie akcje zrzucone gdzie indziej będą wykonywane po bloku "Stosuje się do".
+
Powyższy kod bloku akcji sprawdza zmienną, czy jest równa 100, a jeśli tak, to zmienia zakres
+ na instancje " obj_Player" i każe im uruchomić akcję Set Sprite (wszystkie instancje tego object w room zmienią w tym momencie adres sprite ), po czym kontynuuje
+ dodanie 1 do zmiennej w instancji uruchamiającej pełny blok kodu.
+
+
-
Assign VariableThis action is used to either assign a variable a value (creating it in the process) or for changing the value of an existing variable.
-You give the name of the variable and then the value, which can be added relative to the original value if required. If you give a new variable name (ie: a variable that has never been assigned previously in the instance) then this will create the new variable and assign it the value you give, while if you give the name of an existing variable, it will simply change the value to the new one.
-You can add additional variables in the same action by clicking the plus icon beside the action, and giving another variable name and value. For more advanced information on variables please see the section on Variables And Variable Scope.
Checking Relative will add your new value to the variable's existing value (use a negative number to subtract) and you can also use expressions and variables created previously as the value.
-When we talk about "values", we don't just mean numeric values, as a variable can be a string, a pointer, a resource ID or anything else that a function can return or use. In the case of a string, checking Relative will concatenate the value with whatever the variable previously held, so if your variable was "Hello" and you assign " World" to it using the relative check, the final variable value will be "Hello World".
-Care must be taken, however, to ensure that the variable values are both of the same data type, as trying to add, for example, an integer and a string, will result in a compiler error.
--
Ta czynność służy do przypisania zmiennej wartości (tworząc ją w procesie) lub do zmiany wartości istniejącej zmiennej. Podaje się nazwę zmiennej, a następnie wartość, która w razie potrzeby może zostać dodana w stosunku do wartości oryginalnej. + wymagane. Jeśli podasz nazwę nowej zmiennej (tzn. zmiennej, która nigdy wcześniej nie była przypisana w instancji), to zostanie ona utworzona i zostanie jej przypisana podana przez Ciebie wartość, natomiast jeśli podasz nazwę istniejącej zmiennej, to zostanie ona + po prostu zmieni jej wartość na nową. Zauważ, że zaznaczenie opcji Is Relative spowoduje dodanie wartości do istniejącej wartości zmiennej (użyj liczby ujemnej, aby odjąć), a jako wartości możesz także użyć wyrażenia s i zmiennych utworzonych wcześniej.
+Warto zauważyć, że kiedy mówimy o "wartościach", nie mamy na myśli tylko wartości liczbowych, ponieważ zmienną może być string, wskaźnik, identyfikator zasobu lub cokolwiek innego, co funkcja może zwrócić lub wykorzystać. W przypadku zmiennej string, sprawdzenie Relative spowoduje + konkatenuje wartość z tym, co zmienna posiadała poprzednio, więc jeśli zmienną było "Hello" i przypiszesz do niej " World" za pomocą sprawdzenia relatywnego, końcową wartością zmiennej będzie "Hello World". Należy zachować ostrożność, + jednak, aby obie wartości zmiennych były tego samego typu danych, ponieważ próba dodania, na przykład, liczby całkowitej i string spowoduje błąd kompilatora.
+Należy pamiętać, że w tej samej akcji można dodać dodatkowe zmienne, klikając ikonę plusa obok akcji, a następnie podając nazwę i wartość kolejnej zmiennej.
+ wartość. Bardziej zaawansowane informacje na temat zmiennych można znaleźć w rozdziale Zmienne i zakres zmiennych.
+
| Argument | -Description | +Opis | |
|---|---|---|---|
| Name | -The name of the new variable to assign, or the name of an existing variable to change. | +Name | +Nazwa nowej zmiennej, którą należy przypisać, lub nazwa istniejącej zmiennej, którą należy zmienić. |
| Value | -The value that the variable should hold. | +Value | +Wartość, jaką powinna mieć zmienna. |
| Relative | -Check to set the value relative to the previous one. | +Relative | +Zaznacz, aby ustawić wartość względem poprzedniej. |
-
The above action block code checks two instance variables and if one is higher than another ( if "my_score" is greater than "level_score"), then it sets a number of instance variables to new values.
-
-
+
+
Powyższy kod bloku akcji sprawdza dwie zmienne instancji i jeśli jedna z nich jest większa od drugiej (
+ jeśli "my_score" jest większe niż "level_score"), to ustawia pewną liczbę zmiennych instancji na nowe wartości.
+
+
- - \ No newline at end of file + +
