scrape/scrapeboard
scrape
/
scrapeboard
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

builder's manual

This commit is contained in:
ohsqueezy 2022-12-18 20:09:06 -05:00
parent 14772a45e6
commit 21a856089d
4 changed files with 507 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
README.md
View File

@ -10,14 +10,14 @@ Controller
The controller must be provided by the user, whether it's a standard Scrapeboard mat and board, a custom interface built by the user, or keyboard input. The hardware requirement for [serial mode](#Serial) is an [Arduino][] or Arduino-equivalent device that can run the [serial program][]. For [keyboard mode](#Keys), no special hardware is required, although a gamepad or [Makey Makey][] could be used to create a custom controller that sends key presses.
We are working on an Instructable with details on how to create a standard Scrapeboard mat, board, and circuit! For now, feel free to set up the software and experiment with your own Makey Makey or Arduino interface.
See [Scrapeboard Builder's Manual][Scrapeboard_Builder's_Manual.md] for detailed instructions on how to build a complete system from scratch using an Arduino or Raspberry Pi!
Software
--------
The software requires Python, [Pygame][], and a custom Python game framework [PGFW][]. The Python version should be 3.9 or higher. The Pygame version should be 1.9.6 or higher. PGFW is a submodule of this repository, so it can be cloned simultaneously using the `--recursive` flag. Python and Pygame can be installed on any operating system, including Windows, OS X, and Linux.
Installing Python will usually install Python's package manager PIP as well. PIP can be used to install Pygame by running the following from your terminal (for example, PowerShell on Windows)
Installing Python will usually install Python's package manager PIP as well. PIP can be used to install Pygame by running the following from your terminal (for example, PowerShell on Windows).
pip install pygame
@ -85,9 +85,9 @@ The `--minimize-load-time` flag can be useful when testing because it sacrifices
License
-------
Original Scrapeboard code is released without restriction on copying, modifying, or selling, under the zlib license. Art, sound, text, and schematic assets are released under CC BY 4.0. This means users are free to use Scrapeboard in any context, including modding it and even selling mods or creating a closed source version. Use of the assets requires attribution is given to Scrapeboard for the original assets, and if source is distributed, the zlib license must be included as the license for the original code.
Original Scrapeboard code is released without restriction on copying, modifying, or selling, under the zlib license. Art, sound, text, and schematic assets are released under CC BY 4.0. This means users are free to use Scrapeboard for any use, including modifying it and even selling the modification, and the modifications would not need to be released as open source. Use of the assets requires attribution is given to Scrapeboard for the original assets, and if the source is distributed, the zlib license must be included as the license for the original code.
PGFW is included under its zlib license. Python, Pygame, and Arduino all have their own licenses, but they are not distributed with this project.
PGFW is included under its zlib license. Python, Pygame, Arduino and Raspberry Pi all have their own licenses, but they are not distributed with this project.
See [LICENSE.txt][]

502
Scrapeboard_Builder's_Manual.md Normal file
View File

@ -0,0 +1,502 @@
Scrapeboard Builder's Manual
============================
Scrapeboard is a Dance Dance Revolution inspired alternative controller game that uses a real skateboard deck and metal floor pads for input. Rather than doing moves in time to a rhythm, the goal of Scrapeboard is to do combinations of moves in series as quickly as possible to defeat each level's boss. This manual covers how to build a full Scrapeboard system in sequence from preparing and testing the software to fabricating a controller using a skateboard deck, metal pads and plywood.
It is intended for a general audience. No coding or fabrication experience is required. The code, electronics, and manual are released as open source, so the resulting system is officially licensed to be modified and used for personal, educational, or even commercial use.
An accompanying Instructable and video is currently in production.
Supplies
--------
* [Arduino][3] or [Raspberry Pi (v4 2GB or higher)][4]
* Desktop or laptop computer (not required if using Raspberry Pi)
* Monitor
* 4 × [birch plywood pieces](https://www.homedepot.com/p/Handprint-3-4-in-x-2-ft-x-4-ft-Birch-Plywood-154148/203504324) pre-cut to 15" × 21" × 3/4" each
* 4 × [metal sheets 12" × 18"](https://www.ebay.com/sch?_nkw=12"+x+18"+metal+sheet)
* [Skateboard deck](https://www.ebay.com/sch?_nkw=blank+skateboard+deck)
* 2 × [Surface-mounted anchor rings](https://www.harborfreight.com/4-piece-surface-mounted-rope-rings-97767.html)
* Drill
* HDMI cable
* [Breadboard](https://www.amazon.com/DEYUE-breadboard-Set-Prototype-Board/dp/B07LFD4LT6)
* [Jumper wires](https://www.amazon.com/Elegoo-EL-CP-004-Multicolored-Breadboard-arduino/dp/B01EV70C78)
* 4 × [4.7k resistors](https://www.amazon.com/EDGELEC-Resistor-Tolerance-Multiple-Resistance/dp/B07QJB3LGN)
* 4 × [5mm screw terminals](https://www.amazon.com/Tnisesm-0-2inch-Terminal-Connector-Spliced/dp/B088LSS14J)
* 52 × [Flat-head sheet metal screws #8 3/4"](https://www.amazon.com/dp/B08F75F6BV)
* 4 × Metal washers
* 20' [16 AWG wire](https://www.ebay.com/itm/272488348389)
* 8 × Brackets ([Flat metal brackets with 5/8" screws](https://www.amazon.com/dp/B07Z8YLFCN) if not using a router or [Latches with mounting screws](https://www.amazon.com/Stainless-Mounting-MERYSAN-Premium-Overall/dp/B07GKHD61X) otherwise)
* [Non-slip floor padding](https://www.amazon.com/dp/B09QS47P21)
* 6 × #10-24 3/4" Flat-head machine [screws](https://www.amazon.com/dp/B08474HKMT) with [hex nuts](https://www.amazon.com/dp/B082D6FV5H)
* 5 × [#8-1/2" Wood screws](https://www.amazon.com/dp/B09D952RV5)
* [Thin metal strip](https://www.amazon.com/dp/B00745VXN2)
* Straight edge
* Pencil
* Measuring tape
* Wire strippers (recommended)
* [WD-40](https://www.amazon.com/dp/B00IOX8M0A/) (recommended)
* Wrench (recommended)
* Screwdriver (recommended)
* Sandpaper (recommended)
* [Carpet tape](https://www.amazon.com/dp/B07H88SWCM) (optional)
* [Router](https://www.amazon.com/dp/B01M0J08MF) (optional)
* [Straight bits](https://www.amazon.com/dp/B09HSVD9H2) (optional)
Preparing a computer
--------------------
Choosing the computer depends primarily on whether an Arduino or Raspberry Pi is being used for the electronics. This manual covers both of the following options.
* ordinary desktop or laptop with 2GB or more RAM, along with an Arduino for the electronics
* 2GB RAM or higher Raspberry Pi 4 to run both the game and electronics
There is support built into the game for both Arduino and Raspberry Pi, so the decision can be based on what is available or familiar, and whether or not the game needs to be portable. The Arduino option is a bit more beginner friendly since a personal computer can be used and the Arduino is a beginner friendly electronics platform.
### Non-Raspberry Pi
Systems other than Raspberry Pi don't need special preparation. They are expected to be used as is with an Arduino connected. The OS can be anything that runs Pygame, like a desktop computer or laptop running Windows, OS X, or Linux. It can be used like any ordinary computer by downloading the game software and attaching an Arduino, which will connect to the Scrapeboard pad.
### Raspberry Pi
If using a Raspberry Pi, it must have 2GB or higher RAM, and only the Raspberry Pi version 4 has been tested. This manual covers in detail how to install everything from scratch on an empty SD card using a Raspberry Pi OS Lite.
#### Supplies
* Raspberry Pi 4 with 2GB or more RAM and power supply
* 4GB or larger micro SD card
* SD card reader
* HDMI cable
* HDMI-compatible external display
* USB Keyboard
* Wi-fi or LAN connection for Raspberry Pi
#### Instructions
##### Imager
* Get Raspberry Pi imager from <https://www.raspberrypi.com/software/> and launch it (note: must be run as authorized user)
* Choose `"Raspberry Pi OS (other)" -> "Raspberry Pi OS Lite (64-bit)"` under `"Operating System"`
* Connect your SD card and choose it under `"Storage"`
##### Imager settings tab
* Click the gear button to open the settings
* Check off "Set hostname" and change to "scrapeboard"
* Check off "Enable SSH" with "Use password authentication"
* Check off "Set username and password" and choose your own username and password
* Check off "Configure wireless LAN" and set the SSID and password for your wi-fi network (if wi-fi is unavailable, you can use the Raspberry Pi's ethernet connection or transfer the Scrapeboard files onto the SD card manually later)
* Check off "Set locale settings" and set to your time zone and keyboard layout
##### Begin installation
* Click "WRITE" in the Imager window
#### Boot
* Insert the SD card into the Raspberry Pi
* Connect the Pi to an external HDMI display
* Connect a keyboard
* Power up the Pi
* Login with the username and password set during installation
* Optional: run `sudo apt update && sudo apt upgrade` to update the operating system
* The system is ready for [installing the game software and other software requirements][]
Installing the game software and other software requirements
------------------------------------------------------------
The software instructions are mostly dependent on the operating system, rather than the type of hardware being used, so they are divided into different sections per OS.
### Requirements
* [Python 3.7+](https://python.org)
* [Pygame 2+](https://pygame.org)
* [Git](https://git-scm.com/)
* [Scrapeboard + PGFW code repository](https://git.nugget.fun/scrape/scrapeboard)
### Python 3
#### Linux / Raspberry Pi
Most likely Python 3 is already installed. If not, install it from the package manager. For example, on Raspberry Pi, run
sudo apt install python3
#### Windows, OSX, other
* Download the appropriate installer from <https://python.org> and follow the system-wide installation instructions.
* If prompted, choose to install pip (the Python package installer) alongside Python.
### Git
Git is only used for getting the Scrapeboard and PGFW software. It is possible to skip installing Git and download each repository as a ZIP file instead, but that is not covered by these instructions.
#### Linux / Raspberry Pi
Install from the package manager
sudo apt install git
#### Windows, OSX, other
Download and install from <https://git-scm.com/downloads>
### Pygame
#### Raspberry Pi OS Lite
Full desktop versions of Raspberry Pi OS will run Pygame normally, so this section only applies to Raspberry Pi OS Lite (no desktop).
Raspberry Pi OS Lite is still using Pygame 1 by default. Scrapeboard, however, is intended to use Pygame 2, which uses SDL2. It is possible to run it on Pygame 1 with SDL1, but 2 is preferred. For Raspberry Pi OS Lite, there are two options. Either use Pygame 1, or compile a custom version of SDL2.
See the following links for more information on why this is necessary.
* <https://stackoverflow.com/questions/57672568/sdl2-on-raspberry-pi-without-x>
* <https://wiki.libsdl.org/FAQUsingSDL#how_do_i_choose_a_specific_video_driver>
* <https://forums.raspberrypi.com/viewtopic.php?t=248621>
* <https://github.com/sm64pc/sm64ex/issues/37>
* <https://forums.raspberrypi.com/viewtopic.php?t=234087#p1437451>
* <https://github.com/pygame/pygame/issues/3003>
##### Pygame 1.9.6 and SDL 1 workaround
Install Pygame using the package manager, and it will install Pygame 1.9.6 with SDL 1, since these are still considered the stable versions on Raspberry Pi OS.
sudo apt install python3-pygame
In `/boot/config.txt`
* Comment out the line `dtoverlay=vc4-kms-v3d`
* Set the framebuffer resolution
* `framebuffer_width=800`
* `framebuffer_height=450`
##### Pygame 2+ and SDL 2 custom installation
To set the resolution, edit `/boot/cmdline.txt` by adding a custom video definition at the end of the file `video=HDMI-A-1:800x450M@60`.
Install initial Pygame dependencies
sudo apt install libfreetype6-dev libportmidi-dev libjpeg-dev python3-setuptools python3-dev python3-numpy
Download [SDL2 source](https://github.com/libsdl-org/SDL/releases/). For example, this will download version 2.24.2.
wget https://github.com/libsdl-org/SDL/releases/download/release-2.24.2/SDL2-2.24.2.tar.gz
tar -xf SDL2-2.24.2.tar.gz
cd SDL2-2.24.2/
Enable `deb-src` repositories by uncommenting the `deb-src` lines in `/etc/apt/sources.list`.
Install everything necessary to build SDL2.
sudo apt update && sudo apt build-dep libsdl2
Configure, make, and install
./configure && make && sudo make install
Download and compile [SDL image][], [SDL ttf][], and [SDL mixer][]
wget https://github.com/libsdl-org/SDL_image/releases/download/release-2.6.2/SDL2_image-2.6.2.tar.gz
wget https://github.com/libsdl-org/SDL_ttf/releases/download/release-2.20.1/SDL2_ttf-2.20.1.tar.gz
wget https://github.com/libsdl-org/SDL_mixer/releases/download/release-2.6.2/SDL2_mixer-2.6.2.tar.gz
tar -xf SDL2_image-2.6.2.tar.gz
cd SDL2_image-2.6.2/
./configure && make && sudo make install
cd ..
tar -xf SDL2_ttf-2.20.1.tar.gz
cd SDL2_ttf-2.20.1/
./configure && make && sudo make install
cd ..
tar -xf SDL2_mixer-2.6.2.tar.gz
cd SDL2_mixer-2.6.2/
./configure && make && sudo make install
sudo ldconfig
Build Pygame
git clone https://github.com/pygame/pygame
cd pygame
python3 setup.py -config -auto
python3 setup.py install --user
This is a general Raspberry Pi audio issue and may not be necessary on all Raspberry Pi OS Lite installations, but it may be necessary to configure sound by replacing the contents of `~/.asoundrc` with
defaults.pcm.card 1
defaults.pcm.device 0
defaults.ctl.card 1
### Linux / non-lite Raspberry Pi
Install pip from the package manager
sudo apt install python3-pip
Install pygame through pip
sudo pip install pygame
#### Windows, OS X, other
For checking if pip needs to be installed and how to install it, see <https://pip.pypa.io/en/stable/getting-started/>. If necessary to install, use pip from the command line (PowerShell or Terminal, for example)
python -m pip install pygame
### Scrapeboard and PGFW
Use Git to clone Scrapeboard with the `--recursive` flag to clone PGFW as well
git clone --recursive https://git.nugget.fun/scrape/scrapeboard
cd scrapeboard/
### Launch
It should be possible to run in keyboard mode and test input with key presses now. The `--no-serial` flag is used to indicate keyboard mode.
#### Linux, Windows, OS × (except Raspberry Pi Lite OS)
./OPEN-GAME --no-serial
#### Raspberry Pi Lite OS
The `--kms` (Kernel Mode Setting) flag is necessary for running on the lite OS because it doesn't have X-windows.
./OPEN-GAME --no-serial --kms
Electronics
-----------
A simple circuit constructed with either an Arduino or Raspberry Pi is necessary to connect the input pads with the game.
### Supplies
* Arduino with USB cable or Raspberry Pi
* [Breadboard](https://www.amazon.com/DEYUE-breadboard-Set-Prototype-Board/dp/B07LFD4LT6)
* [Jumper wires](https://www.amazon.com/Elegoo-EL-CP-004-Multicolored-Breadboard-arduino/dp/B01EV70C78)
* 4 × [4.7k resistors](https://www.amazon.com/EDGELEC-Resistor-Tolerance-Multiple-Resistance/dp/B07QJB3LGN)
* 4 × [5mm screw terminals](https://www.amazon.com/Tnisesm-0-2inch-Terminal-Connector-Spliced/dp/B088LSS14J)
### Circuit
Four input pins on the microcontroller need to be connected to the game's four input pads, with a 4.7k resistor in each connection. With the program loaded onto the microcontroller, when a connection is made between two pads with any conductor, those two pads are registered as connected. The way it works is the code constantly is switching one of every four pads to low output and the others to high input. The low output will pull down the high input if it is connected to it, so if a high input is actually read as low, that means the two pins are connected.
#### Arduino
1. Connect pins 2, 4, 6, and 11 to the breadboard using jumper wires
2. Extend each connection using a 4.7k ohm resistor
3. End each connection with a screw terminal
#### Raspberry Pi
1. Connect pins 11, 13, 15, and 16 to the breadboard using jumper wires (these pins are also referred to as GPIO 17, GPIO 27, GPIO 22, and GPIO 23).
2. Extend each connection using a 4.7k ohm resistor
3. End each connection with a screw terminal
### Loading the program
#### Arduino
Download the [Arduino IDE](https://www.arduino.cc/en/software) and connect it to the Arduino. Open [serial/serial2/serial2.ino](serial/serial2/serial2.ino) in the IDE and load it onto the Arduino.
#### Raspberry Pi
The program will run automatically using a Python library that reads the Raspberry Pi's GPIO pins when the game is launched.
### Testing the circuit
For both of these steps, remember that if the game is running on Raspberry Pi Lite OS, it must also have the `--kms` flag.
#### Arduino
Launch the game without any flags to indicate Arduino (or serial) mode. Serial data being output by the Arduino will be read over USB.
./OPEN-GAME
Connect any two screw terminals using a jumper wire, and the lizard should appear on screen.
#### Raspberry Pi
Launch the game with the `--pi` flag to indicate that input is coming through the Raspberry Pi's GPIO pins.
./OPEN-GAME --pi
Connect any two screw terminals using a jumper wire, and the lizard should appear on screen.
Building a Scrapeboard and platform
-----------------------------------
The controller hardware has two parts: a custom built platform and a modified skatedeck. The platform consists of four metal plates and must be capable of supporting the weight of a person and should not move even under constant friction. The skatedeck is a regular skatedeck with two metal pads drilled into the bottom, connected by a metal strip.
This manual describes how to build the controller hardware using a router to cut channels for insetting the metal plates, brackets, and wiring. However, the routing parts are optional. The original build of this board and controller did not use routing and is still in good working shape after being used for many events. The supplies and instructions are marked optional if they include routing.
### Supplies
* 4 × [birch plywood pieces](https://www.homedepot.com/p/Handprint-3-4-in-x-2-ft-x-4-ft-Birch-Plywood-154148/203504324) pre-cut to 15" × 21" × 3/4" each
* 4 × [aluminum metal sheets 12" × 18"](https://www.ebay.com/sch?_nkw=12"+x+18"+metal+sheet)
* 52 × [Flat-head sheet metal screws #8 3/4"](https://www.amazon.com/dp/B08F75F6BV)
* 4 × Metal washers
* [20' 16 AWG wire](https://www.ebay.com/itm/272488348389)
* 8 × Brackets ([Flat metal brackets with 5/8" screws](https://www.amazon.com/dp/B07Z8YLFCN) if not using a router or [Latches with mounting screws](https://www.amazon.com/Stainless-Mounting-MERYSAN-Premium-Overall/dp/B07GKHD61X) otherwise)
* [Non-slip floor padding](https://www.amazon.com/dp/B09QS47P21)
* [Skateboard deck](https://www.ebay.com/sch?_nkw=blank+skateboard+deck)
* 2 × [Surface-mounted rope rings](https://www.harborfreight.com/4-piece-surface-mounted-rope-rings-97767.html)
* Drill
* 6 × #10-24 3/4" Flat-head machine [screws](https://www.amazon.com/dp/B08474HKMT) with [hex nuts](https://www.amazon.com/dp/B082D6FV5H)
* 5 × [#8-1/2" Wood screws](https://www.amazon.com/dp/B09D952RV5)
* [Thin metal strip](https://www.amazon.com/dp/B00745VXN2)
* Straight edge
* Pencil
* Measuring tape
* Wire strippers (recommended)
* [WD-40](https://www.amazon.com/dp/B00IOX8M0A/) (recommended)
* Wrench (recommended)
* Screwdriver (recommended)
* [Carpet tape](https://www.amazon.com/dp/B07H88SWCM) (optional)
* [Router](https://www.amazon.com/dp/B01M0J08MF) (optional)
* [Straight bits](https://www.amazon.com/dp/B09HSVD9H2) (optional)
* Sandpaper (optional)
### Platform
The platform for a standard Scrapeboard build consists of four evenly spaced metal pads, about 12" × 18" each, spaced 5" apart. The metal pads can be mounted in any manner, as long as they are firmly attached. This manual describes how to mount the metal to four 15" × 21" × 3/4" pre-cut pieces of birch plywood and bracket the pieces together. It also describes how to use a router to inset the metal parts and wiring, but those parts are optional.
#### Measuring
The most significant measurement is the amount of space between the metal plates. This measurement should be consistent among builds using a standard skatedeck. Having the right amount of space ensures that the plates are close enough together that diagonals will be easy to do and far enough apart that a single metal pad underneath the skatedeck won't be able to touch two pads simultaneously. Since the metal pads for the skatedeck are 4" in diameter, the metal plates should be slightly farther apart, about 5" from each horizontal and vertical neighbor.
1. For each of the wood pieces, measure 2.5" inward from the two inner edges, going along each edge, marking off 2.5".
2. Draw a line parallel to the edge of the wood piece on each of the two inner edges. These lines mark where the metal plate should be attached.
#### Inset (optional)
In order to get the metal plates flush with the platform, it is necessary to remove a thin layer of wood from where the metal will be attached. This manual describes how to use a router to cut away a thin layer from all parts of the wood other than the cross section between the metal plates, meaning everything other than the 2.5" just measured on each piece. For a more advanced build, the router could be used to make precise insets into the wood pieces that fit the metal plate exactly.
1. Insert a 3/4" diameter (it can be any diameter, but the larger it is, the less time it will take) straight bit into the router.
2. Adjust the router so it is set to exactly the thickness of the metal (the thickness that will be removed to make the metal flush).
3. Remove a thin layer of wood from the entire region outside the lines previously measured. To do that, set the router along the edge of the wood piece near the farthest corner. Turn on the router and start cutting, moving inward toward the lines. In order to get an even cut and stop the router from going past the lines, a straight edge can be held firmly in place parallel to the lines to stop the router. A straight [edge guide for routers](https://www.amazon.com/dp/B0771Y41W6) can also be used to cut a channel precisely the right amount away from the edge.
#### Wire channels (optional)
In order to keep the wood pieces separable, the wire routing isn't too complex. It just involves carving out channels near the outer corners of wood pieces where the wires can be inserted. However, if the wood pieces don't need to be portable, the channels can be adjusted so that all wires come out of the front of the platform.
1. On each wood piece, at the outermost corner, measure inward to a point that will be about 1" in from the corner of the metal plate and mark the point.
2. Insert a 1/4" diameter bit into the router.
3. On the two front wood pieces (the two closest to the screen), use the router to carve a 3/8" deep channel straight in from the front edge.
4. On the other two wood pieces, do the same, but carving in from the side edges, so the wires will come in from the side of platform, rather than the back.
5. If the metal plates are conductive on both faces, it may be sufficient to stop here and later clamp the wire between the wood and plate when drilling the plates in. However, if the metal plates are conductive on only one face, a hole will need to be drilled near, but not above, the wire channel. The wire can then be inserted into this hole to be clamped by a screw that is drilled through the metal plate and into the wood. To make this hole, mark a point on the metal plate 1/2" away from the channel toward the outer edge. Use a 1/4" drill bit to drill a hole into the metal at this point (since the hole is for only the metal, it might work best to use a piece of scrap wood instead of the platform piece as the backing when drilling into the metal).
#### Wires
There will be four wires total, one for each metal plate. They should be cut long enough to reach the Arduino or Raspberry Pi. To have them all terminate at the same point, the back two wood pieces should have longer wires than the front two.
1. Measure the distance between the Arduino or Raspberry Pi and the platform. This will vary depending on the setup, and it is a good idea to measure extra distance just in case.
2. Cut two wires at the measured distance for the front pieces with some extra inches for inserting and running diagonally.
3. Cut two wires at the measured distance plus an extra 3 or 4 feet for the back pieces.
4. For each wire, at one end use wire strippers to cut off the sheathing and expose about 1/4" of wire. These ends will be inserted into the screw terminals.
5. For each wire, at the other end, use wire strippers to cut off the sheathing and expose 1" or more of wire. These ends will be attached to the metal plates.
#### Metal pads
The metal plates need to be drilled into the platform with the measured cross section between them. The wires then need to be attached to the metal plates.
1. Insert a 7/64" drill bit into the drill.
2. If optional wire channels were carved,
3. For each wood piece, place the metal plate along the measured lines. If using wire channels, the wire should now be inserted into the channel because it will be clamped during the drilling. The wire should be exposed and making contact with the metal, and it should be pinched between the metal and wood.
4. Along the borders of each metal plate, drill 12 evenly spaced sheet metal screws into both the metal and wood. In order to do this, for each screw, first spray a bit of WD-40 at the drill point to help with drilling into metal. Then, pre-drill a small hole through the metal and into the wood. Finally, drill the screw through the metal and into the wood.
5. If not using wire channels or if the metal is only conductive on one face, one more screw and a washer will be needed. The wire should be attached near the outermost corner for each plate. Drill the screw as usual, but this time place a washer between the screw and plate. Drill the screw in but not completely. Wrap the wire around the base, under the washer. Finish drilling the screw in. This should clamp the wire between the washer and the plate.
#### Brackets
The brackets should be attached to the underside of the platform. They are necessary for keeping the pieces together. With 8 - 12 brackets total, the pieces will hold together firmly. The brackets may be inset into the wood using a router. If using the clasp style brackets, this step is necessary. Ordinary flat brackets can be either inset or not.
1. Flip the platform onto its backside, keeping all four pieces arranged in their proper orientation.
2. Along the cross section seam, place the brackets so they are evenly spaced, covering as much area as possible, without getting too close to the edge or the center.
3. (Optional) If doing routing, trace around the bracket to mark where the channel will go.
4. (Optional) Use the router to carve a channel in the same way the wire channels were carved, just deep enough to the bracket will not come out farther than the wood.
5. Directly drill the brackets into the wood using the appropriate screws.
#### Non-slip padding
The non-slip padding is necessary for keeping the platform from slipping on many surfaces. If the platform is placed on a very non-slippery surface like carpet, it may not be necessary. The non-slip padding can be attached to the underside of the wood pieces or it can be placed on the floor between the platform and floor.
1. If attaching the non-slip pad to the wood pieces, first cut the padding into four pieces, each the size of a wood piece.
2. For each wood piece, put carpet tape along the underside of the wood piece, in strips, covering as much area as possible, something like five or so strips along the length of the piece.
3. Firmly press the non-slip padding onto the carpet tape.
#### Connecting
The platform is now finished. It can be connected to the Arduino or Raspberry Pi and tested before moving on to building the board.
1. Carefully flip the platform back over, taking care near the seams because the bracketing will make it susceptible to snapping.
2. For each wire, insert its exposed end into the appropriate screw terminal. Going clockwise from the top left plate, for Arduino, the wires connect to pins 2, 4, 6, and 11. For Raspberry Pi, the wires connect to pins 11, 13, 15, and 16.
3. Use any metal conductor to touch one metal plate to another. The lizard should appear on the screen.
### Scrapeboard
The board for a standard Scrapeboard build is a skatedeck with two metal pads drilled into either end of the bottom and connected with a flat metal strip. The metal pads are actually anchor rings, ordinarily used to hook cargo to a tow cable. They are used because their unique disk shape and slightly raised edges allow for the best motion with the board. Even more than the platform, the board takes a lot of abuse in the standard build, so it's recommended to follow this manual unless building a heavily modified version of the controller.
#### Wire strip
The wire strip is used to connect the metal pads to each other so the signal can pass through. The strip should be attached to the underside, going directly across the length of the middle. The metal pads will then be drilled on top of it.
1. Measure out and cut enough wire strip so that it will go along the entire flat part of the underside of the skatedeck. It doesn't have to go up the curved ends, but it should go past the truck holes.
2. Drill the wire strip directly into the underside of the board using the 1/2" wood screws.
#### Metal pads
The metal pads should be placed slightly farther out than the truck holes and held in place by machine screws and nuts.
1. If using the recommended anchor rings, first remove the ring from the base. Pry up the center flap slightly with a screwdriver or other tool, and the ring should slide out.
2. For each metal pad, place it directly in the center of the underside, with its center about 1" farther toward the end of the board than the truck holes. The center hole of the pad should be directly above the metal strip, ideally lined up with an existing hole in the strip.
3. Insert a 1/4" drill bit into the drill.
4. The center hole of the anchor can be used as a drill point. Use this hole to guide drilling a hole through the wood so that a 3/8" machine screw can fit snugly through. The hole should also pass through the metal strip.
5. Insert the machine screw from the top of the deck through the underside. Attach a nut to the underside and tighten with a wrench and screwdriver.
6. Two more holes need to be drilled on either side of the center hole, through the wood, and out the other side of the deck. The holes must be perpendicular to the length of the board. For each hole, spray some WD-40 and then drill all the way through both the metal and wood.
7. Repeat step 5 for the new holes.
#### Connect
The board and entire build should now be complete. Try placing the board on two metal pads. The lizard should appear on the screen.
Advanced
--------
### Launch Scrapeboard automatically on Raspberry Pi
First, make the Raspberry Pi skip the login prompt. Use the `raspi-config` script and select `System Options -> Boot / Auto Login -> Console Autologin`.
To launch Scrapeboard at startup, create a file at `/etc/systemd/system/scrapeboard.service` with the following contents
[Unit]
Description=It is Scrapeboard you slime bag
After=multi-user.target
[Service]
ExecStart=/home/tony/scrapeboard/OPEN-GAME --go-to-dir --fb
Restart=always
RestartSec=5s
TimeoutStartSec=2min
[Install]
WantedBy=default.target
and enable it
sudo systemctl enable scrapeboard.service
Now Scrapeboard will launch at startup and will restart itself if it ever is closed or crashes, and it can be controlled through `systemd`
> sudo systemctl start scrapeboard
...
> sudo systemctl stop scrapeboard
Since it restarts automatically when quit with the usual quit button, there is also `SHIFT + q` to permanently quit and get back to the Raspberry Pi console.
[SDL mixer]: https://github.com/libsdl-org/SDL_mixer/releases
[SDL ttf]: https://github.com/libsdl-org/SDL_ttf/releases
[SDL image]: https://github.com/libsdl-org/SDL_image/releases
[Erickson surface mount anchor ring #9100]: https://ericksonmfg.com/product/surface-mount-anchor-ring-3/
[1]: https://www.amazon.com/s?k=erickson+9110
[2]: https://www.ebay.com/sch?_nkw=erickson+9110
[3]: https://store-usa.arduino.cc/collections/boards/products/arduino-uno-rev3
[4]: https://www.raspberrypi.com/products/raspberry-pi-4-model-b/

2
lib/pgfw

@ -1 +1 @@
Subproject commit 24b5d7c6e7c7f17ec09ddb3de2127c092aa6f874
Subproject commit 7a1652717931d49c112e8fe75919129b4906d9f4

103
resource/scores
View File

@ -1,103 +0,0 @@
41802 0
41903 0
42153 0
47259 0
48935 0
50940 0
51245 0
51355 0
51372 0
51754 0
52110 0
52736 0
52863 0
53242 0
53715 0
54546 0
54603 0
55707 0
56045 0
56636 0
56732 0
57247 0
57299 0
57326 0
57436 0
57670 0
57885 0
59459 0
60290 0
60440 0
60510 0
60751 0
60824 0
60957 0
61433 0
61677 0
61838 0
62269 0
62562 0
63416 0
64223 0
64412 0
64534 0
64577 0
65496 0
66051 0
66635 0
67401 0
67523 0
68302 0
68541 0
68948 0
69290 0
69510 0
70404 0
70528 0
71138 0
71335 0
71495 0
71627 0
73511 0
73848 0
74455 0
75015 0
75387 0
75646 0
76002 0
76945 0
77434 0
77526 0
77701 0
79705 0
82020 0
82777 0
87726 0
90718 0
91883 0
73379 1
80500 1
81857 1
89673 1
93372 1
93427 1
97111 1
105880 1
107336 1
108024 1
109913 1
111785 1
112993 1
113387 1
114742 1
116102 1
117369 1
117614 1
117744 1
119812 1
120058 1
120493 1
66801 2
85743 2
86038 2
103819 2