From b62af486a7847e4105a2cfd0be8722df2e09042b Mon Sep 17 00:00:00 2001 From: Andras Schmelczer Date: Sat, 6 Jun 2026 15:23:48 +0100 Subject: [PATCH] Add christmas edition --- .gitignore | 1 - christmas/AdAstra.atsln | 19 + christmas/AdAstra/AdAstra.componentinfo.xml | 4 + christmas/AdAstra/AdAstra.cproj | 396 ++++++++++++++++++ christmas/AdAstra/AdAstra.xml | 86 ++++ .../AdAstra/src/driver/display/display.c | 137 ++++++ .../AdAstra/src/driver/display/display.h | 74 ++++ christmas/AdAstra/src/driver/infra/infra.c | 144 +++++++ christmas/AdAstra/src/driver/infra/infra.h | 24 ++ .../redundant_storage/redundant_storage.c | 120 ++++++ .../redundant_storage/redundant_storage.h | 22 + christmas/AdAstra/src/driver/sleep/sleep.c | 39 ++ christmas/AdAstra/src/driver/sleep/sleep.h | 16 + .../src/hardware_access/eeprom/eeprom.c | 75 ++++ .../src/hardware_access/eeprom/eeprom.h | 15 + .../src/hardware_access/hardware_access.c | 12 + .../src/hardware_access/hardware_access.h | 39 ++ .../hardware_access/output_pins/output_pins.c | 11 + .../hardware_access/output_pins/output_pins.h | 7 + .../power_saving/power_saving.h | 13 + .../AdAstra/src/hardware_access/spi/spi.c | 30 ++ .../AdAstra/src/hardware_access/spi/spi.h | 15 + .../src/hardware_access/timing/timing.c | 17 + .../src/hardware_access/timing/timing.h | 13 + christmas/AdAstra/src/macros/bitwise.h | 11 + christmas/AdAstra/src/macros/math.h | 9 + christmas/AdAstra/src/macros/null.h | 3 + christmas/AdAstra/src/main.c | 14 + christmas/AdAstra/src/mediator/mediator.c | 74 ++++ christmas/AdAstra/src/mediator/mediator.h | 23 + christmas/AdAstra/src/objects/ai/ai.c | 235 +++++++++++ christmas/AdAstra/src/objects/ai/ai.h | 12 + .../AdAstra/src/objects/commands/commands.c | 71 ++++ .../AdAstra/src/objects/commands/commands.h | 38 ++ .../objects/event_generator/event_generator.c | 80 ++++ .../objects/event_generator/event_generator.h | 16 + christmas/AdAstra/src/objects/object.c | 41 ++ christmas/AdAstra/src/objects/object.h | 78 ++++ .../object_container/object_container.c | 61 +++ .../object_container/object_container.h | 58 +++ christmas/AdAstra/src/objects/prototype.c | 22 + christmas/AdAstra/src/objects/prototype.h | 28 ++ .../src/objects/types/asteroid/asteroid.c | 51 +++ .../src/objects/types/asteroid/asteroid.h | 25 ++ .../src/objects/types/astronaut/astronaut.c | 137 ++++++ .../src/objects/types/astronaut/astronaut.h | 37 ++ .../src/objects/types/background/background.c | 71 ++++ .../src/objects/types/background/background.h | 18 + .../AdAstra/src/objects/types/bullet/bullet.c | 40 ++ .../AdAstra/src/objects/types/bullet/bullet.h | 16 + .../src/objects/types/spaceship/spaceship.c | 225 ++++++++++ .../src/objects/types/spaceship/spaceship.h | 75 ++++ christmas/AdAstra/src/objects/types/sprites.c | 16 + christmas/AdAstra/src/objects/types/sprites.h | 19 + .../AdAstra/src/objects/types/text/text.c | 114 +++++ .../AdAstra/src/objects/types/text/text.h | 21 + .../AdAstra/src/objects/types/text/texts.c | 8 + .../AdAstra/src/objects/types/text/texts.h | 11 + christmas/AdAstra/src/util/random/random.c | 14 + christmas/AdAstra/src/util/random/random.h | 14 + .../AdAstra/src/util/rectangle/rectangle.c | 34 ++ .../AdAstra/src/util/rectangle/rectangle.h | 26 ++ christmas/AdAstra/src/util/vec2/vec2.c | 24 ++ christmas/AdAstra/src/util/vec2/vec2.h | 26 ++ christmas/Felhasználói dokumentáció.docx | Bin 0 -> 229528 bytes christmas/Felhasználói dokumentáció.pdf | Bin 0 -> 220866 bytes christmas/text_generator/README.md | 15 + .../input/.vscode/settings.json | 14 + christmas/text_generator/input/adam.txt | 13 + christmas/text_generator/input/apa.txt | 11 + christmas/text_generator/input/balazs.txt | 11 + christmas/text_generator/input/oliver.txt | 12 + christmas/text_generator/main.py | 121 ++++++ christmas/text_generator/requirements.txt | 1 + 74 files changed, 3422 insertions(+), 1 deletion(-) create mode 100644 christmas/AdAstra.atsln create mode 100644 christmas/AdAstra/AdAstra.componentinfo.xml create mode 100644 christmas/AdAstra/AdAstra.cproj create mode 100644 christmas/AdAstra/AdAstra.xml create mode 100644 christmas/AdAstra/src/driver/display/display.c create mode 100644 christmas/AdAstra/src/driver/display/display.h create mode 100644 christmas/AdAstra/src/driver/infra/infra.c create mode 100644 christmas/AdAstra/src/driver/infra/infra.h create mode 100644 christmas/AdAstra/src/driver/redundant_storage/redundant_storage.c create mode 100644 christmas/AdAstra/src/driver/redundant_storage/redundant_storage.h create mode 100644 christmas/AdAstra/src/driver/sleep/sleep.c create mode 100644 christmas/AdAstra/src/driver/sleep/sleep.h create mode 100644 christmas/AdAstra/src/hardware_access/eeprom/eeprom.c create mode 100644 christmas/AdAstra/src/hardware_access/eeprom/eeprom.h create mode 100644 christmas/AdAstra/src/hardware_access/hardware_access.c create mode 100644 christmas/AdAstra/src/hardware_access/hardware_access.h create mode 100644 christmas/AdAstra/src/hardware_access/output_pins/output_pins.c create mode 100644 christmas/AdAstra/src/hardware_access/output_pins/output_pins.h create mode 100644 christmas/AdAstra/src/hardware_access/power_saving/power_saving.h create mode 100644 christmas/AdAstra/src/hardware_access/spi/spi.c create mode 100644 christmas/AdAstra/src/hardware_access/spi/spi.h create mode 100644 christmas/AdAstra/src/hardware_access/timing/timing.c create mode 100644 christmas/AdAstra/src/hardware_access/timing/timing.h create mode 100644 christmas/AdAstra/src/macros/bitwise.h create mode 100644 christmas/AdAstra/src/macros/math.h create mode 100644 christmas/AdAstra/src/macros/null.h create mode 100644 christmas/AdAstra/src/main.c create mode 100644 christmas/AdAstra/src/mediator/mediator.c create mode 100644 christmas/AdAstra/src/mediator/mediator.h create mode 100644 christmas/AdAstra/src/objects/ai/ai.c create mode 100644 christmas/AdAstra/src/objects/ai/ai.h create mode 100644 christmas/AdAstra/src/objects/commands/commands.c create mode 100644 christmas/AdAstra/src/objects/commands/commands.h create mode 100644 christmas/AdAstra/src/objects/event_generator/event_generator.c create mode 100644 christmas/AdAstra/src/objects/event_generator/event_generator.h create mode 100644 christmas/AdAstra/src/objects/object.c create mode 100644 christmas/AdAstra/src/objects/object.h create mode 100644 christmas/AdAstra/src/objects/object_container/object_container.c create mode 100644 christmas/AdAstra/src/objects/object_container/object_container.h create mode 100644 christmas/AdAstra/src/objects/prototype.c create mode 100644 christmas/AdAstra/src/objects/prototype.h create mode 100644 christmas/AdAstra/src/objects/types/asteroid/asteroid.c create mode 100644 christmas/AdAstra/src/objects/types/asteroid/asteroid.h create mode 100644 christmas/AdAstra/src/objects/types/astronaut/astronaut.c create mode 100644 christmas/AdAstra/src/objects/types/astronaut/astronaut.h create mode 100644 christmas/AdAstra/src/objects/types/background/background.c create mode 100644 christmas/AdAstra/src/objects/types/background/background.h create mode 100644 christmas/AdAstra/src/objects/types/bullet/bullet.c create mode 100644 christmas/AdAstra/src/objects/types/bullet/bullet.h create mode 100644 christmas/AdAstra/src/objects/types/spaceship/spaceship.c create mode 100644 christmas/AdAstra/src/objects/types/spaceship/spaceship.h create mode 100644 christmas/AdAstra/src/objects/types/sprites.c create mode 100644 christmas/AdAstra/src/objects/types/sprites.h create mode 100644 christmas/AdAstra/src/objects/types/text/text.c create mode 100644 christmas/AdAstra/src/objects/types/text/text.h create mode 100644 christmas/AdAstra/src/objects/types/text/texts.c create mode 100644 christmas/AdAstra/src/objects/types/text/texts.h create mode 100644 christmas/AdAstra/src/util/random/random.c create mode 100644 christmas/AdAstra/src/util/random/random.h create mode 100644 christmas/AdAstra/src/util/rectangle/rectangle.c create mode 100644 christmas/AdAstra/src/util/rectangle/rectangle.h create mode 100644 christmas/AdAstra/src/util/vec2/vec2.c create mode 100644 christmas/AdAstra/src/util/vec2/vec2.h create mode 100644 christmas/Felhasználói dokumentáció.docx create mode 100644 christmas/Felhasználói dokumentáció.pdf create mode 100644 christmas/text_generator/README.md create mode 100644 christmas/text_generator/input/.vscode/settings.json create mode 100644 christmas/text_generator/input/adam.txt create mode 100644 christmas/text_generator/input/apa.txt create mode 100644 christmas/text_generator/input/balazs.txt create mode 100644 christmas/text_generator/input/oliver.txt create mode 100644 christmas/text_generator/main.py create mode 100644 christmas/text_generator/requirements.txt diff --git a/.gitignore b/.gitignore index 27aa5e8..e8d9acd 100644 --- a/.gitignore +++ b/.gitignore @@ -5,4 +5,3 @@ **/.vs **/bin .DS_Store -christmas diff --git a/christmas/AdAstra.atsln b/christmas/AdAstra.atsln new file mode 100644 index 0000000..14ee877 --- /dev/null +++ b/christmas/AdAstra.atsln @@ -0,0 +1,19 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Atmel Studio Solution File, Format Version 11.00 +VisualStudioVersion = 14.0.23107.0 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{54F91283-7BC4-4236-8FF9-10F437C3AD48}") = "AdAstra", "AdAstra\AdAstra.cproj", "{DCE6C7E3-EE26-4D79-826B-08594B9AD897}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Release|AVR = Release|AVR + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {DCE6C7E3-EE26-4D79-826B-08594B9AD897}.Release|AVR.ActiveCfg = Release|AVR + {DCE6C7E3-EE26-4D79-826B-08594B9AD897}.Release|AVR.Build.0 = Release|AVR + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/christmas/AdAstra/AdAstra.componentinfo.xml b/christmas/AdAstra/AdAstra.componentinfo.xml new file mode 100644 index 0000000..52c412d --- /dev/null +++ b/christmas/AdAstra/AdAstra.componentinfo.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/christmas/AdAstra/AdAstra.cproj b/christmas/AdAstra/AdAstra.cproj new file mode 100644 index 0000000..6553768 --- /dev/null +++ b/christmas/AdAstra/AdAstra.cproj @@ -0,0 +1,396 @@ + + + + 2.0 + 7.0 + com.Atmel.AVRGCC8.C + dce6c7e3-ee26-4d79-826b-08594b9ad897 + ATtiny85 + none + Executable + C + $(MSBuildProjectName) + .elf + $(MSBuildProjectDirectory)\$(Configuration) + TestProject + TestProject + TestProject + Native + false + false + false + true + 0x20000000 + + false + exception_table + 2 + 0 + 0 + + + + + + + + + + + + + + com.atmel.avrdbg.tool.ispmk2 + 000200212345 + 0x1E930B + ISP + 125000 + + + + 125000 + + ISP + + com.atmel.avrdbg.tool.ispmk2 + 000200212345 + AVRISP mkII + + + + + + + + + com.atmel.avrdbg.tool.simulator + + + Simulator + + + + + + -mmcu=attiny85 -B "%24(PackRepoDir)\atmel\ATtiny_DFP\1.3.229\gcc\dev\attiny85" + True + True + True + True + False + True + True + True + + + NDEBUG + + + + + %24(PackRepoDir)\atmel\ATtiny_DFP\1.3.229\include + ../src/macros + + + Optimize for size (-Os) + True + True + True + True + True + + + libm + + + + + %24(PackRepoDir)\atmel\ATtiny_DFP\1.3.229\include + + + + + ad_astra + .elf + + + + + -mmcu=attiny85 -B "%24(PackRepoDir)\atmel\ATtiny_DFP\1.3.229\gcc\dev\attiny85" + True + True + True + True + False + True + True + + + DEBUG + + + + + %24(PackRepoDir)\atmel\ATtiny_DFP\1.3.229\include + + + Optimize (-O1) + True + True + Default (-g2) + True + + + libm + + + + + %24(PackRepoDir)\atmel\ATtiny_DFP\1.3.229\include + + + Default (-Wa,-g) + + + + + + + -mmcu=attiny85 -B "%24(PackRepoDir)\atmel\ATtiny_DFP\1.3.229\gcc\dev\attiny85" + True + True + True + True + True + False + True + True + + + NDEBUG + UART_ENABLED + + + + + %24(PackRepoDir)\atmel\ATtiny_DFP\1.3.229\include + + + Optimize for size (-Os) + True + True + True + True + True + + + libm + + + + + %24(PackRepoDir)\atmel\ATtiny_DFP\1.3.229\include + + + + + ad_astra + .elf + bin\WithUART\ + + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + compile + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/christmas/AdAstra/AdAstra.xml b/christmas/AdAstra/AdAstra.xml new file mode 100644 index 0000000..121a635 --- /dev/null +++ b/christmas/AdAstra/AdAstra.xml @@ -0,0 +1,86 @@ + + + + + + + Device + Startup + + + Atmel + 1.3.0 + C:/Program Files (x86)\Atmel\Studio\7.0\Packs + + + + + C:/Program Files (x86)\Atmel\Studio\7.0\Packs\atmel\ATtiny_DFP\1.3.229\include + + include + C + + + include + + + + + C:/Program Files (x86)\Atmel\Studio\7.0\Packs\atmel\ATtiny_DFP\1.3.229\include\avr\iotn85.h + + header + C + RcYmivGpgsCGGCzeWAIjcA== + + include/avr/iotn85.h + + + + + C:/Program Files (x86)\Atmel\Studio\7.0\Packs\atmel\ATtiny_DFP\1.3.229\templates\main.c + template + source + C Exe + 9ptzGqB00V1zM0TC00KMag== + + templates/main.c + Main file (.c) + + + + C:/Program Files (x86)\Atmel\Studio\7.0\Packs\atmel\ATtiny_DFP\1.3.229\templates\main.cpp + template + source + C Exe + YXFphlh0CtZJU+ebktABgQ== + + templates/main.cpp + Main file (.cpp) + + + + C:/Program Files (x86)\Atmel\Studio\7.0\Packs\atmel\ATtiny_DFP\1.3.229\gcc\dev\attiny85 + + libraryPrefix + GCC + + + gcc/dev/attiny85 + + + + + ATtiny_DFP + C:/Program Files (x86)/Atmel/Studio/7.0/Packs/atmel/ATtiny_DFP/1.3.229/Atmel.ATtiny_DFP.pdsc + 1.3.229 + true + ATtiny85 + + + + Resolved + Fixed + true + + + \ No newline at end of file diff --git a/christmas/AdAstra/src/driver/display/display.c b/christmas/AdAstra/src/driver/display/display.c new file mode 100644 index 0000000..a1b6259 --- /dev/null +++ b/christmas/AdAstra/src/driver/display/display.c @@ -0,0 +1,137 @@ +#include "display.h" + +#include + +#include "bitwise.h" +#include "math.h" +#include "../../hardware_access/hardware_access.h" + + +static uint8_t const configuration[] PROGMEM = { + 0xD5, 0xF0, // set clock frequency + 0x8D, 0x14, // enable charge pump + 0x20, 0x00, // horizontal addressing mode + 0xD6, 0x01, // 2 times vertical zoom + 0x22, 0x00, 0x03, // only draw to the top half of the screen + 0xAF // display on +}; + +static struct { + uint8_t compositingBuffer[DISPLAY_WIDTH_IN_PIXELS]; + Rectangle compositingWindow; + DrawFunction drawEverything; + bool wasIntersection; +} display; + +static inline void commandMode() { + setOutputPin(DISPLAY_DC_OUTPUT_PIN, false); +} + +static inline void dataMode() { + setOutputPin(DISPLAY_DC_OUTPUT_PIN, true); +} + +void setDisplayContrast(uint8_t value) { + commandMode(); + sendByteOnSPI(0x81); + sendByteOnSPI(value); + dataMode(); +} + +void turnDisplayOnOff(bool shouldBeOn) { + commandMode(); + sendByteOnSPI(0x8D | shouldBeOn); // set charge pump on/off + sendByteOnSPI(0x10 | shouldBeOn << 2); // set charge pump on/off + sendByteOnSPI(0xAE | shouldBeOn); // turn display sleep on/off + dataMode(); +} + +void initializeDisplay(DrawFunction drawEverything) { + setOutputPin(DISPLAY_RESET_OUTPUT_PIN, false); + for (volatile uint8_t i = 0; i != 255; i++) + ; + // some time has to elapse before the next line gets called, + // otherwise the display wont turn on + setOutputPin(DISPLAY_RESET_OUTPUT_PIN, true); + + for (uint8_t i = 0; i < sizeof(configuration); i++) { + sendByteOnSPI(pgm_read_byte(configuration + i)); + } + + display.drawEverything = drawEverything; + setDisplayContrast(255); + dataMode(); +} + +void startIntersectionTest(Rectangle compositingWindow) { + display.wasIntersection = false; + display.compositingWindow = compositingWindow; +} + +bool endIntersectionTest() { + for (uint8_t x = 0; x < DISPLAY_WIDTH_IN_PIXELS; x++) { + display.compositingBuffer[x] = 0; + } + return display.wasIntersection; +} + +void drawFrame() { + display.compositingWindow = DEFAULT_COMPOSITING_WINDOW; + for (display.compositingWindow.position.y = 0; display.compositingWindow.position.y < DISPLAY_HEIGHT_IN_PIXELS; display.compositingWindow.position.y += 8) { + display.drawEverything(display.compositingWindow); + + for (uint8_t x = 0; x < DISPLAY_WIDTH_IN_PIXELS; x++) { + sendByteOnSPI(display.compositingBuffer[x]); + sendByteOnSPI(display.compositingBuffer[x]); + display.compositingBuffer[x] = 0; + } + } +} + +static void compositePixelColumn(uint8_t x, uint8_t invertedMask, uint8_t fill) { + if (display.compositingBuffer[x] & fill) { + display.wasIntersection = true; + } + display.compositingBuffer[x] = (display.compositingBuffer[x] & (~invertedMask)) | fill; +} + +void drawBitmapFromProgMem(Rectangle boundingBox, uint16_t const bitmap[boundingBox.size.x][(boundingBox.size.y + 7) / 8], bool isMirrored) { + boundingBox.position = substract(boundingBox.position, display.compositingWindow.position); + + uint8_t spriteY = max(0, -boundingBox.position.y); + uint8_t spriteYByte = spriteY >> 3; + + for (uint8_t x = max(0, -boundingBox.position.x); x < boundingBox.size.x && boundingBox.position.x + x < DISPLAY_WIDTH_IN_PIXELS; x++) { + uint8_t spriteX = isMirrored ? boundingBox.size.x - x - 1 : x; + uint16_t currentPixelColumn = pgm_read_word(&bitmap[spriteX][spriteYByte]); + + uint8_t fill, invertedMask; + if (boundingBox.position.y >= 0) { + fill = (currentPixelColumn & 0x00FF) << boundingBox.position.y; + invertedMask = currentPixelColumn >> 8 << boundingBox.position.y; + } else { + uint16_t lowerPixelColumn = spriteYByte + 1 < (boundingBox.size.y + 7) / 8 ? pgm_read_word(&bitmap[spriteX][spriteYByte + 1]) : 0; + uint8_t shift = spriteY % 8; + uint8_t inverseShift = 8 - shift; + + fill = ((currentPixelColumn & 0x00FF) >> shift) | ((lowerPixelColumn & 0x0FF) << inverseShift); + invertedMask = (currentPixelColumn >> 8 >> shift) | (lowerPixelColumn >> 8 << inverseShift); + } + + compositePixelColumn(boundingBox.position.x + x, invertedMask, fill); + } +} + +void drawFilledRectangle(Rectangle box, uint8_t invertedMask, uint8_t fill) { + box.position = substract(box.position, display.compositingWindow.position); + + uint8_t upperGapHeight = min(8, max(0, box.position.y)); + uint8_t lowerGapHeight = min(8, max(0, 8 - (box.position.y + box.size.y))); + + uint8_t actualFill = (fill >> lowerGapHeight) & (fill << upperGapHeight); + uint8_t actualInvertedMask = (invertedMask >> lowerGapHeight) & (invertedMask << upperGapHeight); + + for (uint8_t x = max(0, box.position.x); x < box.position.x + box.size.x && x < DISPLAY_WIDTH_IN_PIXELS; x++) { + compositePixelColumn(x, actualInvertedMask, actualFill); + } +} diff --git a/christmas/AdAstra/src/driver/display/display.h b/christmas/AdAstra/src/driver/display/display.h new file mode 100644 index 0000000..37681e1 --- /dev/null +++ b/christmas/AdAstra/src/driver/display/display.h @@ -0,0 +1,74 @@ +#ifndef DISPLAY_H +#define DISPLAY_H + +#include +#include + +#include "../../util/rectangle/rectangle.h" + + +/* + SPI driver for D096-12864 +*/ + +#define DISPLAY_RESET_OUTPUT_PIN PB0 +#define DISPLAY_DC_OUTPUT_PIN PB4 + +// A two-times downscaling is used for greater performance +#define DISPLAY_WIDTH_IN_PIXELS 64 +#define DISPLAY_HEIGHT_IN_PIXELS 32 + +// To easily access the window size +#define WINDOW ((Rectangle){(Vec2){0, 0}, (Vec2){DISPLAY_WIDTH_IN_PIXELS, DISPLAY_HEIGHT_IN_PIXELS}}) + +// To conserve RAM, drawing is done in chunks of DEFAULT_COMPOSITING_WINDOW size +// instead of buffering the whole display and writing it out at once +#define DEFAULT_COMPOSITING_WINDOW ((Rectangle){(Vec2){0, 0}, (Vec2){DISPLAY_WIDTH_IN_PIXELS, 8}}) + +typedef void (*DrawFunction)(Rectangle); + +// Call DrawFunction n times after a call to drawFrame has been made +void initializeDisplay(DrawFunction drawEverything); + +// Set a the brightness of the display +// Value can be any number between 0 and 255. +void setDisplayContrast(uint8_t value); + +// To conserve program memory, pixel based intersection test +// is implemented here. +// Calling draw functions after calling startIntersectionTest +// will set a wasIntersection bit appropriately. + +// Clear buffer and wasIntersection bit +void startIntersectionTest(); + +// Make the display go to / return from sleep +void turnDisplayOnOff(bool shouldBeOn); + +// Return wasIntersection bit +bool endIntersectionTest(); + +// Initiate a draw sequence +void drawFrame(); + +// Draw a sprite of size boundingBox.size at boundingBox.position from bitmap +// if isMirrored then mirror around the vertical axis +// Bitmap's data is interpreted the following way: +/* + Each 16 bit word corresponds to an 8 pixel high column. + (These columns are laid out horizontally from left to right. Unfortunately, + the display uses this addressing mode.) The higher 8 bits of the word is the + inverted mask and the lower 8 bits are the fill bits. + newPixelColumn = oldPixelColumn & ~invertedMask | fill; + + This seemingly weird layout is used to take advantage of SIMD operations + and speed up the drawing process significantly. +*/ +void drawBitmapFromProgMem(Rectangle boundingBox, uint16_t const bitmap[boundingBox.size.x][(boundingBox.size.y + 7) / 8], bool isMirrored); + +// Draw a one byte repeated texture covering the parameter box +// for a white rectangle use these arguments: invertedMask: don't care, fill: 0xFF +// for a black rectangle use these arguments: invertedMask: 0xFF, fill: 0x00 +void drawFilledRectangle(Rectangle box, uint8_t invertedMask, uint8_t fill); + +#endif diff --git a/christmas/AdAstra/src/driver/infra/infra.c b/christmas/AdAstra/src/driver/infra/infra.c new file mode 100644 index 0000000..0459e78 --- /dev/null +++ b/christmas/AdAstra/src/driver/infra/infra.c @@ -0,0 +1,144 @@ +#include "infra.h" + +#include +#include + +#include "bitwise.h" +#include "../../hardware_access/hardware_access.h" + + +// (0.5625 + (0.5625 + 1.6875) / 2) / 1000 / timer interval +#define MEAN_OF_0_1_BIT_TIMES 53 +// 9 / 2 / 1000 / timer interval +#define MAYBE_ONE_CHECK_TIME 141 +// some large value +#define TIMEOUT 254 + +typedef enum { + idle, maybeLeadingOne, leadingOneConfirmed, activeFirstBit, active, timingOut +} ProtocolState; + +typedef enum { + noMatch, foundStartingByte, significantByte, waitingForEndOfCommand, waitingForRepeat +} CommandState; + +static struct { + uint8_t current; + uint8_t bitPosition; + ProtocolState protocolState; + CommandState commandState; + OnCommandReceived onCommandReceived; +} infra; + + +static void saveCurrentByte() { + uint8_t byte = infra.current; + infra.current = 0; + infra.bitPosition = 0; + + if (byte == INFRA_ADDRESS) { + infra.commandState = foundStartingByte; + return; + } + + switch (infra.commandState) { + case foundStartingByte: + infra.commandState = significantByte; + break; + case significantByte: + infra.onCommandReceived(byte); + infra.commandState = waitingForEndOfCommand; + break; + case waitingForEndOfCommand: + if (byte == 0) { + infra.commandState = waitingForRepeat; + } + break; + case waitingForRepeat: + if (byte == 0) { + infra.onCommandReceived(REPEAT_CODE); + } + break; + default: + break; + } +} + +static void saveBit(uint8_t bit) { + infra.current <<= 1; + infra.current |= bit; + if (++infra.bitPosition == 8) { + saveCurrentByte(); + } +} + +static inline uint8_t isIrOff() { + return getBit(PINB, IR_PIN); +} + +static inline uint8_t isIrOn() { + return !isIrOff(); +} + +ISR(PCINT0_vect) { + switch (infra.protocolState) { + case idle: + if (isIrOn()) { + enableTimerB(MAYBE_ONE_CHECK_TIME); + infra.protocolState = maybeLeadingOne; + } + break; + case maybeLeadingOne: + infra.protocolState = idle; + break; + case leadingOneConfirmed: + if (isIrOff()) { + infra.protocolState = activeFirstBit; + } + break; + case activeFirstBit: + case timingOut: + if (isIrOn()) { + infra.protocolState = active; + enableTimerB(MEAN_OF_0_1_BIT_TIMES); + } + break; + case active: + if (isIrOn()) { + saveBit(1); + enableTimerB(MEAN_OF_0_1_BIT_TIMES); + } + break; + } +} + +ISR(TIM0_COMPB_vect) { + switch (infra.protocolState) { + case maybeLeadingOne: + if (isIrOn()) { + infra.protocolState = leadingOneConfirmed; + } + disableTimerB(); + break; + case active: + saveBit(0); + infra.protocolState = timingOut; + enableTimerB(TIMEOUT); + break; + case timingOut: + infra.protocolState = idle; + saveCurrentByte(); + disableTimerB(); + break; + default: + disableTimerB(); + break; + } +} + +void initializeInfra(OnCommandReceived onCommandReceived) { + setBit(PORTB, IR_PIN); // enable pull-up + setBit(PCMSK, IR_PIN); // specific pin change interrupt enable + setBit(GIMSK, PCIE); // global on pin change interrupt enable; + infra.onCommandReceived = onCommandReceived; +} diff --git a/christmas/AdAstra/src/driver/infra/infra.h b/christmas/AdAstra/src/driver/infra/infra.h new file mode 100644 index 0000000..312d3e5 --- /dev/null +++ b/christmas/AdAstra/src/driver/infra/infra.h @@ -0,0 +1,24 @@ +#ifndef INFRA_H +#define INFRA_H + +#include +#include + + +/* + Custom NEC implementation using a TSOP4838 +*/ + +#define INFRA_ADDRESS 255 +#define IR_PIN PB3 +#define REPEAT_CODE 1 + +typedef void (*OnCommandReceived)(uint8_t); +typedef void (*OnReceiveStarted)(); + +// Initialize infra and call onCommandReceived with every received byte +// Call onCommandReceived with the argument REPEAT_CODE if a repeat code +// has been received. +void initializeInfra(OnCommandReceived onCommandReceived); + +#endif diff --git a/christmas/AdAstra/src/driver/redundant_storage/redundant_storage.c b/christmas/AdAstra/src/driver/redundant_storage/redundant_storage.c new file mode 100644 index 0000000..6d43090 --- /dev/null +++ b/christmas/AdAstra/src/driver/redundant_storage/redundant_storage.c @@ -0,0 +1,120 @@ +#include "redundant_storage.h" + +#include "../../hardware_access/hardware_access.h" + +#define offsetof(type, member) __builtin_offsetof (type, member) + +#define OBJECT_VALIDITY_MASK (0b00111111) +#define IS_USING_PAGE_A_BIT 6 +#define IS_VALID_BIT 7 +#define METADATA_REDUNDANCY 4 + +typedef struct { + uint8_t redundantBufferA[REDUNDANT_BUFFER_SIZE]; + uint8_t redundantBufferB[REDUNDANT_BUFFER_SIZE]; + uint8_t metadata[METADATA_REDUNDANCY]; +} MemoryLayout; + +static volatile struct { + MemoryLayout buffer; + uint8_t saveIndex; + uint8_t* savePointer; + uint8_t loadIndex; + uint8_t* loadPointer; + uint8_t validMetadata; + bool isEEPROMWriting; +} storage; + +static inline bool isUsingPageA() { + return getBit(storage.validMetadata, IS_USING_PAGE_A_BIT); +} + +bool isValid() { + return getBit(storage.validMetadata, IS_VALID_BIT); +} + +static inline void fixMetadata() { + uint8_t a = storage.buffer.metadata[0]; + uint8_t b = storage.buffer.metadata[1]; + uint8_t c = storage.buffer.metadata[2]; + uint8_t d = storage.buffer.metadata[3]; + + if (a == b || a == c || a == d) { + storage.validMetadata = a; + } else if (b == c || b == d) { + storage.validMetadata = b; + } else { + storage.validMetadata = c; + } +} + +void initializeRedundantStorage() { + for (uint8_t i = 0; i < sizeof(MemoryLayout); i++) { + ((uint8_t*)&storage.buffer)[i] = loadSavedByteEEPROM(i); + } + + fixMetadata(); +} + +void invalidateEEPROM() { + for (uint8_t i = 0; i < sizeof(MemoryLayout); i++) { + ((uint8_t*)&storage.buffer)[i] = 0; + } + + storage.validMetadata = 0; +} + +void onEEPROMWriteFinished(__attribute__((unused)) uint8_t* _) { + storage.isEEPROMWriting = false; +} + +bool startSchedulingObjectsForSaving() { + if (storage.isEEPROMWriting) { + return false; + } + + toggleBit(storage.validMetadata, IS_USING_PAGE_A_BIT); + storage.validMetadata &= ~OBJECT_VALIDITY_MASK; + storage.saveIndex = 0; + storage.savePointer = isUsingPageA() ? + storage.buffer.redundantBufferA + : storage.buffer.redundantBufferB; + + return true; +} + +void scheduleNextObjectForSave(uint8_t* object, uint8_t size) { + setBit(storage.validMetadata, storage.saveIndex); + storage.saveIndex++; + for (uint8_t i = 0; i < size; i++) { + *storage.savePointer = object[i]; + storage.savePointer++; + } +} + +void saveScheduledObjects() { + setBit(storage.validMetadata, IS_VALID_BIT); + + for (uint8_t i = 0; i < METADATA_REDUNDANCY; i++) { + storage.buffer.metadata[i] = storage.validMetadata; + } + + storage.isEEPROMWriting = true; + asyncWriteEEPROM((uint8_t*)&storage.buffer, onEEPROMWriteFinished); +} + +bool loadNextObject(uint8_t* holder, uint8_t size) { + if (storage.loadIndex++ == 0) { + storage.loadPointer = isUsingPageA() ? + storage.buffer.redundantBufferA + : storage.buffer.redundantBufferB; + } + + if (getBit(storage.validMetadata, storage.loadIndex - 1)) { + for (uint8_t i = 0; i < size; i++) { + holder[i] = *storage.loadPointer++; + } + return true; + } + return false; +} diff --git a/christmas/AdAstra/src/driver/redundant_storage/redundant_storage.h b/christmas/AdAstra/src/driver/redundant_storage/redundant_storage.h new file mode 100644 index 0000000..18117a7 --- /dev/null +++ b/christmas/AdAstra/src/driver/redundant_storage/redundant_storage.h @@ -0,0 +1,22 @@ +#ifndef REDUNDANT_STORAGE_H +#define REDUNDANT_STORAGE_H + +#include +#include + + +#define REDUNDANT_BUFFER_SIZE 24 + +void initializeRedundantStorage(); + +bool isValid(); +void invalidateEEPROM(); + +bool startSchedulingObjectsForSaving(); +void scheduleNextObjectForSave(uint8_t* object, uint8_t size); +void saveScheduledObjects(); + +// Returns is loaded object valid +bool loadNextObject(uint8_t* holder, uint8_t size); + +#endif diff --git a/christmas/AdAstra/src/driver/sleep/sleep.c b/christmas/AdAstra/src/driver/sleep/sleep.c new file mode 100644 index 0000000..b6f0adf --- /dev/null +++ b/christmas/AdAstra/src/driver/sleep/sleep.c @@ -0,0 +1,39 @@ +#include "sleep.h" + +#include +#include +#include + +#include "bitwise.h" +#include "../../hardware_access/hardware_access.h" + + +#define TICKS_IN_MILISECOND 31 + +volatile int8_t milisecondsSinceFrameStart; + +void startFrameLoop(FrameFunction function, uint8_t frameLengthInMilliseconds) { + sleep_enable(); + + uint8_t previousFrameTime = 0; + while (function(previousFrameTime)) { + previousFrameTime = milisecondsSinceFrameStart; + + while (milisecondsSinceFrameStart < frameLengthInMilliseconds) { + clearBit(MCUCR, SM1); // idle mode + sleep_cpu(); + } + + milisecondsSinceFrameStart = 0; + } +} + +void powerOff() { + setBit(MCUCR, SM1); // power-down mode + sleep_cpu(); +} + +ISR(TIM0_COMPA_vect) { + milisecondsSinceFrameStart++; + enableTimerA(TICKS_IN_MILISECOND); +} \ No newline at end of file diff --git a/christmas/AdAstra/src/driver/sleep/sleep.h b/christmas/AdAstra/src/driver/sleep/sleep.h new file mode 100644 index 0000000..fe6a7ea --- /dev/null +++ b/christmas/AdAstra/src/driver/sleep/sleep.h @@ -0,0 +1,16 @@ +#ifndef SLEEP_H +#define SLEEP_H + +#include +#include + +// FrameFunction gets previousFrameTime (in milliseconds) as argument +typedef bool (*FrameFunction)(uint8_t); + +// Shut down the machine +void powerOff(); + +// Call function every frameLengthInMilliseconds while it returns true +void startFrameLoop(FrameFunction function, uint8_t frameLengthInMilliseconds); + +#endif diff --git a/christmas/AdAstra/src/hardware_access/eeprom/eeprom.c b/christmas/AdAstra/src/hardware_access/eeprom/eeprom.c new file mode 100644 index 0000000..dac0795 --- /dev/null +++ b/christmas/AdAstra/src/hardware_access/eeprom/eeprom.c @@ -0,0 +1,75 @@ +#include "eeprom.h" + +#include +#include +#include + +#include "bitwise.h" + + +uint8_t memory[STORAGE_SIZE] EEMEM; + +static volatile struct { + uint8_t* buffer; + uint8_t positon; + bool isWriting; + OnEEPROMFinished onFinished; +} eeprom; + +uint8_t loadByteEEPROM(uint8_t* address) { + while(getBit(EECR, EEPE)) {} + + EEAR = (uint16_t)address; + setBit(EECR, EERE); + return EEDR; +} + +uint8_t loadSavedByteEEPROM(uint8_t address) { + return loadByteEEPROM(memory + address); +} + +uint16_t loadWordEEPROM(uint16_t const* address) { + uint16_t high = ((uint16_t)loadByteEEPROM((uint8_t*)address + 1)) << 8; + uint16_t low = (uint16_t)loadByteEEPROM((uint8_t*)address); + return high | low; +} + +static inline void saveByteEEPROM(uint8_t* address, uint8_t byte) { + if (byte != loadByteEEPROM(address)) { + EEDR = byte; + setBit(EECR, EEMPE); + setBit(EECR, EEPE); + } +} + +void enableWritingEEPROM() { + modifyBit(EECR, EERIE, eeprom.isWriting); +} + +void disableWritingEEPROM() { + clearBit(EECR, EERIE); // clear eeprom ready interrupt enable +} + +bool asyncWriteEEPROM(uint8_t* buffer, OnEEPROMFinished onFinished) { + if (eeprom.isWriting) { + return false; + } + + eeprom.buffer = buffer; + eeprom.onFinished = onFinished; + eeprom.positon = 0; + eeprom.isWriting = true; + setBit(EECR, EERIE); // set eeprom ready interrupt + + return true; +} + +ISR(EE_RDY_vect) { + saveByteEEPROM(memory + eeprom.positon, eeprom.buffer[eeprom.positon]); + + if (++eeprom.positon == STORAGE_SIZE) { + clearBit(EECR, EERIE); + eeprom.isWriting = false; + eeprom.onFinished(eeprom.buffer); + } +} diff --git a/christmas/AdAstra/src/hardware_access/eeprom/eeprom.h b/christmas/AdAstra/src/hardware_access/eeprom/eeprom.h new file mode 100644 index 0000000..60627c8 --- /dev/null +++ b/christmas/AdAstra/src/hardware_access/eeprom/eeprom.h @@ -0,0 +1,15 @@ +#ifndef EEPROM_H +#define EEPROM_H + +#include + + +#define STORAGE_SIZE 52 + +typedef void (*OnEEPROMFinished)(uint8_t*); + +inline void initializeEEPROM() { + EECR = 0; // atomic write +} + +#endif diff --git a/christmas/AdAstra/src/hardware_access/hardware_access.c b/christmas/AdAstra/src/hardware_access/hardware_access.c new file mode 100644 index 0000000..ebc04ea --- /dev/null +++ b/christmas/AdAstra/src/hardware_access/hardware_access.c @@ -0,0 +1,12 @@ +#include "hardware_access.h" + +#include + + +void initializeHardwareAccess() { + sei(); + initializePowerSaving(); + initializeSPI(); + initializeTiming(); + initializeOutputPins(); +} diff --git a/christmas/AdAstra/src/hardware_access/hardware_access.h b/christmas/AdAstra/src/hardware_access/hardware_access.h new file mode 100644 index 0000000..e236e4c --- /dev/null +++ b/christmas/AdAstra/src/hardware_access/hardware_access.h @@ -0,0 +1,39 @@ +#ifndef HARDWARE_ACCESS_H +#define HARDWARE_ACCESS_H + +#include +#include +#include "bitwise.h" + +#include "power_saving/power_saving.h" +#include "spi/spi.h" +#include "timing/timing.h" +#include "output_pins/output_pins.h" + + +/* + This module contains the lowest level functions to manipulate the hardware. + You only have to include this header file which serves as a facade. + The sub-modules' implementation can be freely changed as long as they + still implement these functions. +*/ + +// Initialize every hardware element at once +void initializeHardwareAccess(); + +// Enable interrupt OCCRA for TIMER0 with a modulo of triggerInterruptInXTicks +void enableTimerA(uint8_t triggerInterruptInXTicks); + +// Enable interrupt OCCRB for TIMER0B with a modulo of triggerInterruptInXTicks +void enableTimerB(uint8_t triggerInterruptInXTicks); +void disableTimerB(); + +// Send a single byte on the built-in SPI interface +// The transfer is done in a serial manner to achieve +// greater throughput. +void sendByteOnSPI(uint8_t byte); + +// Set the value of an output pin +void setOutputPin(uint8_t id, bool value); + +#endif diff --git a/christmas/AdAstra/src/hardware_access/output_pins/output_pins.c b/christmas/AdAstra/src/hardware_access/output_pins/output_pins.c new file mode 100644 index 0000000..aa8f07e --- /dev/null +++ b/christmas/AdAstra/src/hardware_access/output_pins/output_pins.c @@ -0,0 +1,11 @@ +#include "output_pins.h" +#include "bitwise.h" + +#include +#include + + +void setOutputPin(uint8_t id, bool value) { + setBit(DDRB, id); + modifyBit(PORTB, id, value); +} diff --git a/christmas/AdAstra/src/hardware_access/output_pins/output_pins.h b/christmas/AdAstra/src/hardware_access/output_pins/output_pins.h new file mode 100644 index 0000000..8d3b8a5 --- /dev/null +++ b/christmas/AdAstra/src/hardware_access/output_pins/output_pins.h @@ -0,0 +1,7 @@ +#ifndef GPIO_OUTPUT_PINS_H +#define GPIO_OUTPUT_PINS_H + + +inline void initializeOutputPins() {} + +#endif diff --git a/christmas/AdAstra/src/hardware_access/power_saving/power_saving.h b/christmas/AdAstra/src/hardware_access/power_saving/power_saving.h new file mode 100644 index 0000000..a4abd37 --- /dev/null +++ b/christmas/AdAstra/src/hardware_access/power_saving/power_saving.h @@ -0,0 +1,13 @@ +#ifndef POWER_SAVING_H +#define POWER_SAVING_H + +#include +#include "bitwise.h" + + +inline void initializePowerSaving() { + setBit(ACSR, ACD); // disable ADC to save power + PRR = BV(PRTIM1) | BV(PRADC); // disable power to timer1 and ADC +} + +#endif diff --git a/christmas/AdAstra/src/hardware_access/spi/spi.c b/christmas/AdAstra/src/hardware_access/spi/spi.c new file mode 100644 index 0000000..32a31dd --- /dev/null +++ b/christmas/AdAstra/src/hardware_access/spi/spi.c @@ -0,0 +1,30 @@ +#include "spi.h" + +#include + +#define SWAP_BIT (BV(USIWM0) | BV(USICLK) | BV(USITC) | BV(USICS1)) + + +void sendByteOnSPI(uint8_t byte) { + USIDR = byte; + + USICR = SWAP_BIT; + USICR = SWAP_BIT; + USICR = SWAP_BIT; + USICR = SWAP_BIT; + + USICR = SWAP_BIT; + USICR = SWAP_BIT; + USICR = SWAP_BIT; + USICR = SWAP_BIT; + + USICR = SWAP_BIT; + USICR = SWAP_BIT; + USICR = SWAP_BIT; + USICR = SWAP_BIT; + + USICR = SWAP_BIT; + USICR = SWAP_BIT; + USICR = SWAP_BIT; + USICR = SWAP_BIT; +} diff --git a/christmas/AdAstra/src/hardware_access/spi/spi.h b/christmas/AdAstra/src/hardware_access/spi/spi.h new file mode 100644 index 0000000..9eca28a --- /dev/null +++ b/christmas/AdAstra/src/hardware_access/spi/spi.h @@ -0,0 +1,15 @@ +#ifndef SPI_H +#define SPI_H + +#include +#include "bitwise.h" + + +#define DO_PIN PB1 +#define USCK_PIN PB2 + +inline void initializeSPI() { + DDRB |= BV(DO_PIN) | BV(USCK_PIN); // set pin directions for MOSI and SCK +} + +#endif diff --git a/christmas/AdAstra/src/hardware_access/timing/timing.c b/christmas/AdAstra/src/hardware_access/timing/timing.c new file mode 100644 index 0000000..4069557 --- /dev/null +++ b/christmas/AdAstra/src/hardware_access/timing/timing.c @@ -0,0 +1,17 @@ +#include "timing.h" +#include "bitwise.h" + + +void enableTimerA(uint8_t triggerInterruptInXTicks) { + OCR0A = TCNT0 + triggerInterruptInXTicks; +} + +void enableTimerB(uint8_t triggerInterruptInXTicks) { + setBit(TIFR, OCF0B); + OCR0B = TCNT0 + triggerInterruptInXTicks; + setBit(TIMSK, OCIE0B); +} + +void disableTimerB() { + clearBit(TIMSK, OCIE0B); +} diff --git a/christmas/AdAstra/src/hardware_access/timing/timing.h b/christmas/AdAstra/src/hardware_access/timing/timing.h new file mode 100644 index 0000000..758f0c1 --- /dev/null +++ b/christmas/AdAstra/src/hardware_access/timing/timing.h @@ -0,0 +1,13 @@ +#ifndef TIMING_H +#define TIMING_H + +#include +#include "bitwise.h" + + +inline void initializeTiming() { + TCCR0B = BV(CS02); // CLK / 256 + setBit(TIMSK, OCIE0A); +} + +#endif diff --git a/christmas/AdAstra/src/macros/bitwise.h b/christmas/AdAstra/src/macros/bitwise.h new file mode 100644 index 0000000..e8eb48a --- /dev/null +++ b/christmas/AdAstra/src/macros/bitwise.h @@ -0,0 +1,11 @@ +#ifndef BITWISE_H +#define BITWISE_H + +#define BV(x) (1 << (x)) +#define modifyBit(P, B, V) ((P) = ((P) & ~BV(B)) | ((V) << B)) +#define setBit(P, B) ((P) |= BV(B)) +#define clearBit(P, B) ((P) &= ~BV(B)) +#define toggleBit(P, B) ((P) ^= BV(B)) +#define getBit(P, B) (((P) & BV(B)) >> (B)) + +#endif diff --git a/christmas/AdAstra/src/macros/math.h b/christmas/AdAstra/src/macros/math.h new file mode 100644 index 0000000..5347d60 --- /dev/null +++ b/christmas/AdAstra/src/macros/math.h @@ -0,0 +1,9 @@ +#ifndef MATH_H +#define MATH_H + + +#define max(a, b) ((a) > (b) ? (a) : (b)) +#define min(a, b) ((a) > (b) ? (b) : (a)) +#define abs(a, b) ((a) > 0 ? (a) : (-a)) + +#endif diff --git a/christmas/AdAstra/src/macros/null.h b/christmas/AdAstra/src/macros/null.h new file mode 100644 index 0000000..2090ad6 --- /dev/null +++ b/christmas/AdAstra/src/macros/null.h @@ -0,0 +1,3 @@ +#ifndef NULL +#define NULL ((void*)0) +#endif diff --git a/christmas/AdAstra/src/main.c b/christmas/AdAstra/src/main.c new file mode 100644 index 0000000..77760e4 --- /dev/null +++ b/christmas/AdAstra/src/main.c @@ -0,0 +1,14 @@ +#include "mediator/mediator.h" + + +// Stemming from the module oriented nature of the project +// there is a module responsible for setting up and orchestrating +// the other modules. +// +// From the main function we only have to instruct the mediator to +// do its job. + +int main(void) { + setupConnections(); + startGame(); +} diff --git a/christmas/AdAstra/src/mediator/mediator.c b/christmas/AdAstra/src/mediator/mediator.c new file mode 100644 index 0000000..2ee5689 --- /dev/null +++ b/christmas/AdAstra/src/mediator/mediator.c @@ -0,0 +1,74 @@ +#include "mediator.h" + +#include + +#include "../hardware_access/hardware_access.h" +#include "../objects/object_container/object_container.h" +#include "../objects/event_generator/event_generator.h" +#include "../objects/commands/commands.h" +#include "../objects/ai/ai.h" +#include "../driver/display/display.h" +#include "../driver/infra/infra.h" +#include "../driver/sleep/sleep.h" + +#define TARGET_FRAME_DURATION 20 // ms +#define DEATH_SCREEN_LENGTH 50 // frames +#define SAVE_INTERVAL 50 // every x frames + +static struct { + uint8_t contrast; + uint8_t framesSinceLastSave; + uint8_t deathDownCounter; + uint8_t receivedWakeUpBitCount; +} state = { + .contrast = 255 +}; + +static inline bool handleDeathAnimation() { + if (isSpaceshipDestroyed()) { + setDisplayContrast(state.contrast * (state.deathDownCounter / DEATH_SCREEN_LENGTH)); + if (state.deathDownCounter-- == 0) { + return false; + }; + } + return true; +} + +static bool frameFunction(uint8_t previousFrameTime) { + tickObjects(previousFrameTime); + handleCommands(); + handleAI(); + generateEvents(); + drawFrame(); + return handleDeathAnimation(); +} + +static inline void initializeGame() { + state.deathDownCounter = DEATH_SCREEN_LENGTH; + setDisplayContrast(state.contrast); + initializeBackground(); + initializeObjectContainer(); +} + +void setupConnections() { + initializeHardwareAccess(); + initializeInfra(addCommand); + initializeDisplay(drawObjects); +} + +void startGame() { + while (true) { + initializeGame(); + startFrameLoop(frameFunction, TARGET_FRAME_DURATION); + } +} + +void changeDisplayContrast(int8_t by) { + if (by < 0) { + state.contrast = (state.contrast < -by) ? 0 : (state.contrast + by); + } else { + state.contrast = (state.contrast > 255 - by) ? 255 : (state.contrast + by); + } + + setDisplayContrast(state.contrast); +} diff --git a/christmas/AdAstra/src/mediator/mediator.h b/christmas/AdAstra/src/mediator/mediator.h new file mode 100644 index 0000000..5dba541 --- /dev/null +++ b/christmas/AdAstra/src/mediator/mediator.h @@ -0,0 +1,23 @@ +#ifndef MEDIATOR_H +#define MEDIATOR_H + +#include + + +// Setup the drivers, and business layer objects and their relations +// It is kind of a very basic dependency injection. +void setupConnections(); + +// Start drawing frames and ticking objects +void startGame(); + +// Make the machine go to sleep +void handleOff(); + +// Increase or decrease the contrast (brightness) of the display +// by the given value +// The contrast can be any number between 0 and 255. +// The function automatically clamps the contrast. +void changeDisplayContrast(int8_t by); + +#endif diff --git a/christmas/AdAstra/src/objects/ai/ai.c b/christmas/AdAstra/src/objects/ai/ai.c new file mode 100644 index 0000000..d894545 --- /dev/null +++ b/christmas/AdAstra/src/objects/ai/ai.c @@ -0,0 +1,235 @@ +#include "ai.h" + +#include +#include + +#include "../object_container/object_container.h" +#include "../types/astronaut/astronaut.h" +#include "../types/spaceship/spaceship.h" +#include "../../util/rectangle/rectangle.h" +#include "../../util/random/random.h" +#include "../../driver/display/display.h" + + +#define AI_ACTION_COUNT 5 + +typedef bool (*Predicate)(Rectangle*, Object*, uint8_t); +typedef void (*Execution)(Object*); + +static uint8_t timeSinceLastAction; + + +typedef struct { + Predicate predicate; + Execution execution; + SpaceshipPart* spaceshipPart; + bool onlyOneAstronautCanDoIt; + Vec2 deltaCenter; + bool isSomeoneDoingThis; +} AIAction; + +static AIAction actions[AI_ACTION_COUNT]; + + +static Vec2 whichDirectionToMove(Object* astronaut, Vec2 position) { + bool const isTargetOnUpperFloor = isOnUpperFloor((Rectangle){position, (Vec2){0, 0}}); // else it's on the lower floor + + Vec2 const ladder = add(LADDER_BOUNDING_BOX.position, spaceshipObject->position); + + Vec2 astronautCenter = getCenter(getBoundingBox(astronaut)); + Vec2 target = astronautCenter; + if (( + isOnUpperFloor(getBoundingBox(astronaut)) && isTargetOnUpperFloor + ) || ( + isOnLowerFloor(getBoundingBox(astronaut)) && !isTargetOnUpperFloor + )) { + target.x = position.x; + } else if (isOnLadder(getBoundingBox(astronaut))){ + target.y = add(position, (Vec2){0, isTargetOnUpperFloor ? -10 : 10}).y; + } else { + target.x = ladder.x; + } + + return clampVec2(substract(target, astronautCenter)); +} + +static void carefullyMoveAstronaut(Object* astronaut, Vec2 target) { + if (getIsControllingSpaceship(astronaut)) { + makeAstronautDoAction(astronaut); + } + if (!getIsControllingSpaceship(astronaut)) { + moveAstronaut(astronaut, whichDirectionToMove(astronaut, target)); + } +} + +static void carefullyMoveSpaceship(Object* astronaut, Vec2 target) { + if (!getIsControllingSpaceship(astronaut)) { + makeAstronautDoAction(astronaut); + } + if (getIsControllingSpaceship(astronaut)) { + Vec2 direction = clampVec2( + substract( + target, + getCenter(getBoundingBox(spaceshipObject)) + ) + ); + + moveAstronaut(astronaut, direction); + } +} + +static void makeAiAstronautDoAction(Object* astronaut) { + if (timeSinceLastAction > AI_ACTION_INTERVAL) { + makeAstronautDoAction(astronaut); + timeSinceLastAction = 0; + } +} + +static bool shouldControlTurret( + __attribute__((unused)) Rectangle* boundingBox, + __attribute__((unused)) Object* astronaut, + __attribute__((unused)) uint8_t astronautId +) { + return getCountOf(&Asteroid) > 0; +} + +static void executeControlTurret(Object* astronaut) { + if (getIntersectingObjectOfType( + (Rectangle){ + add(TURRET_POSITION, spaceshipObject->position), + (Vec2){63, 1} + }, + &Asteroid + )) { + makeAiAstronautDoAction(astronaut); + }; +} + +static bool shouldControlSpaceship( + __attribute__((unused)) Rectangle* boundingBox, + __attribute__((unused)) Object* astronaut, + uint8_t astronautId +) { + return getCountOf(&Asteroid) > 0 + && astronautId == 1 + && spaceshipObject->as.spaceship.healthLoss < MAX_HEALTH / 4 * 3; +} + +static void executeControlSpaceship(Object* astronaut) { + carefullyMoveSpaceship( + astronaut, + add( + getCenter(getBoundingBox(getFirstOfType(&Asteroid))), + (Vec2){-30, 0} + ) + ); +} + +static bool shouldRepairSpaceship(Rectangle* boundingBox, Object* astronaut, __attribute__((unused)) uint8_t astronautId) { + return ( + ( + areIntersecting(*boundingBox, getBoundingBox(astronaut)) && + spaceshipObject->as.spaceship.healthLoss > 0 + ) || + spaceshipObject->as.spaceship.healthLoss >= MAX_HEALTH / 2 + ); +} + +static bool shouldCenterSpaceship(Rectangle* boundingBox, Object* astronaut, __attribute__((unused)) uint8_t astronautId) { + return ( + !actions[1].isSomeoneDoingThis && + ( + areIntersecting(*boundingBox, getBoundingBox(astronaut)) || + getCenter(getBoundingBox(spaceshipObject)).x != getCenter(WINDOW).x || + getCenter(getBoundingBox(spaceshipObject)).y != getCenter(WINDOW).y + ) + ); +} + +static void executeCenterSpaceship(Object* astronaut) { + carefullyMoveSpaceship( + astronaut, + getCenter(WINDOW) + ); +} + +static bool shouldSocialize( + __attribute__((unused)) Rectangle* boundingBox, + __attribute__((unused)) Object* astronaut, + __attribute__((unused)) uint8_t astronautId +) { + return true; +} + +static void executeSocialize(Object* astronaut) {} + +static AIAction actions[AI_ACTION_COUNT] = { + (AIAction) { + .predicate = shouldRepairSpaceship, + .execution = makeAiAstronautDoAction, + .spaceshipPart = spaceshipParts + BEDS_INDEX, + .onlyOneAstronautCanDoIt = true, + .deltaCenter = {2, 0} + }, + (AIAction) { + .predicate = shouldControlSpaceship, + .execution = executeControlSpaceship, + .spaceshipPart = spaceshipParts + COMMAND_PANEL_INDEX, + .onlyOneAstronautCanDoIt = true, + .deltaCenter = {-3, 0} + }, + (AIAction) { + .predicate = shouldControlTurret, + .execution = executeControlTurret, + .spaceshipPart = spaceshipParts + TURRET_CONTROLLER_INDEX, + .onlyOneAstronautCanDoIt = true, + .deltaCenter = {-3, 0} + }, + (AIAction) { + .predicate = shouldCenterSpaceship, + .execution = executeCenterSpaceship, + .spaceshipPart = spaceshipParts + COMMAND_PANEL_INDEX, + .onlyOneAstronautCanDoIt = true, + .deltaCenter = {-3, 0} + }, + (AIAction) { + .predicate = shouldSocialize, + .execution = executeSocialize, + .spaceshipPart = spaceshipParts + TABLE_INDEX, + .onlyOneAstronautCanDoIt = false, + .deltaCenter = {2, 0} + }, +}; + +void handleAI() { + timeSinceLastAction++; + uint8_t astronautCount = 0; + for (uint8_t j = 0; j < ACTION_COUNT; j++) { + actions[j].isSomeoneDoingThis = false; + } + + for (uint8_t i = 0; i < OBJECT_COUNT; i++) { + if (objects[i].prototype == &Astronaut && objects + i != character) { + astronautCount++; + for (uint8_t j = 0; j < ACTION_COUNT; j++) { + AIAction* currentAction = actions + j; + Rectangle boundingBox = getBoundingBoxOfSpaceshipPart(currentAction->spaceshipPart); + + Object* astronautIntersectingBoundingBox = getIntersectingObjectOfType(boundingBox, &Astronaut); + if ( + isSpaceshipPartActivated(currentAction->spaceshipPart) && + (!currentAction->onlyOneAstronautCanDoIt || (!currentAction->isSomeoneDoingThis && astronautIntersectingBoundingBox != character)) && + currentAction->predicate(&boundingBox, objects + i, astronautCount) + ) { + if (!areIntersecting(boundingBox, getBoundingBox(objects + i))) { + carefullyMoveAstronaut(objects + i, add(getCenter(boundingBox), currentAction->deltaCenter)); + } else { + currentAction->execution(objects + i); + } + currentAction->isSomeoneDoingThis = true; + break; + } + } + } + } +} diff --git a/christmas/AdAstra/src/objects/ai/ai.h b/christmas/AdAstra/src/objects/ai/ai.h new file mode 100644 index 0000000..37c7e6e --- /dev/null +++ b/christmas/AdAstra/src/objects/ai/ai.h @@ -0,0 +1,12 @@ +#ifndef AI_H +#define AI_H + +// Between AI astronauts do actions +// there has to be at least this many frames +#define AI_ACTION_INTERVAL 30 + +// If there are non player controlled astronauts +// control them according to some basic rule set +void handleAI(); + +#endif diff --git a/christmas/AdAstra/src/objects/commands/commands.c b/christmas/AdAstra/src/objects/commands/commands.c new file mode 100644 index 0000000..8399e6c --- /dev/null +++ b/christmas/AdAstra/src/objects/commands/commands.c @@ -0,0 +1,71 @@ +#include "commands.h" + +#include "../../objects/object_container/object_container.h" +#include "../../objects/types/spaceship/spaceship.h" +#include "../../mediator/mediator.h" + + +static struct { + Command received[COMMAND_BUFFER_SIZE]; + uint8_t start; + uint8_t end; + Command previous; +} commands; + + +static inline bool areThereAnyCommandsLeft() { + return commands.start != commands.end; +} + +static inline Command getNextCommand() { + Command top = commands.received[commands.start++]; + commands.start %= COMMAND_BUFFER_SIZE; + return top; +} + +void addCommand(Command command) { + commands.received[commands.end++] = command; + commands.end %= COMMAND_BUFFER_SIZE; +} + +void handleCommands() { + while(areThereAnyCommandsLeft()) { + Command next = getNextCommand(); + if (next == repeat) { + next = commands.previous; + } else { + commands.previous = next; + } + + switch(next) { + case increaseContrast: + changeDisplayContrast(CONTRAST_STEP); + break; + case decreaseContrast: + changeDisplayContrast(-CONTRAST_STEP); + break; + case moveLeft: + moveAstronaut(character, directions[west]); + break; + case moveRight: + moveAstronaut(character, directions[east]); + break; + case moveUp: + moveAstronaut(character, directions[north]); + break; + case moveDown: + moveAstronaut(character, directions[south]); + break; + case reset: + destroySpaceship(); + commands.previous = noAction; + break; + case action: + makeAstronautDoAction(character); + commands.previous = noAction; + break; + default: + break; + } + } +} \ No newline at end of file diff --git a/christmas/AdAstra/src/objects/commands/commands.h b/christmas/AdAstra/src/objects/commands/commands.h new file mode 100644 index 0000000..5649986 --- /dev/null +++ b/christmas/AdAstra/src/objects/commands/commands.h @@ -0,0 +1,38 @@ +#ifndef COMMANDS_H +#define COMMANDS_H + + +#include + +// There can be no more than COMMAND_BUFFER_SIZE commands +// waiting for processing simultaneously +#define COMMAND_BUFFER_SIZE 8 + +// increaseContrast and decreaseContrast changes the contrast +// with this value +#define CONTRAST_STEP 15 + +// The possible inputs of the system +// Coincidentally these are the codes of the IR remote +// controller's buttons. +typedef enum { + noCommand = 0, + repeat = 1, + reset = 157, + increaseContrast = 87, + decreaseContrast = 31, + moveUp = 231, + moveDown = 181, + moveLeft = 239, + moveRight = 165, + action = 199, +} Command; + +// Add a new command to the buffer +// It will not be processed immediately. +void addCommand(Command command); + +// Process every command in the buffer at once in a FIFO manner +void handleCommands(); + +#endif diff --git a/christmas/AdAstra/src/objects/event_generator/event_generator.c b/christmas/AdAstra/src/objects/event_generator/event_generator.c new file mode 100644 index 0000000..e782e9a --- /dev/null +++ b/christmas/AdAstra/src/objects/event_generator/event_generator.c @@ -0,0 +1,80 @@ +#include "event_generator.h" + +#include +#include + +#include "null.h" + +#include "../object.h" +#include "../object_container/object_container.h" +#include "../types/spaceship/spaceship.h" +#include "../types/background/background.h" +#include "../types/astronaut/astronaut.h" +#include "../types/asteroid/asteroid.h" +#include "../types/text/text.h" +#include "../../util/random/random.h" +#include "../../driver/display/display.h" + + +typedef bool (*Predicate)(Rectangle*); + + +static inline Vec2 getRandomPosition() { + return (Vec2) { + getRandomNumber() % DISPLAY_WIDTH_IN_PIXELS, + getRandomNumber() % DISPLAY_HEIGHT_IN_PIXELS + }; +} + +static void generate(Prototype const* type, Predicate predicate) { + Object* emptySpace = getEmptyObjectSpace(); + if (emptySpace == NULL || getRandomNumber() != 0) { + return; + } + + for (uint8_t tryCount = 0; tryCount < TRY_COUNT; tryCount++) { + Rectangle proposedBoundingBox = (Rectangle){getRandomPosition(), getSizeFromPrototype(type)}; + + if (predicate(&proposedBoundingBox)) { + createObject(type, emptySpace); + emptySpace->position = proposedBoundingBox.position; + return; + } + } +} + +bool generateAstronautPredicate(Rectangle* proposedBoundingBox) { + return ( + ( + (getCountOf(&Astronaut) == 1 && spaceshipObject->as.spaceship.progress >= hasHalfCrew) || + (getCountOf(&Astronaut) == 2 && spaceshipObject->as.spaceship.progress >= hasTable) + ) && + getIntersectingObjectOfType(*proposedBoundingBox, &Astronaut) == NULL && + isOnboard(*proposedBoundingBox) + ); +} + +bool generateAsteroidPredicate(Rectangle* proposedBoundingBox) { + return ( + getCountOf(&Asteroid) < MAX_ASTEROID_COUNT && + isInside(*proposedBoundingBox, WINDOW) && + getIntersectingObjectOfType(*proposedBoundingBox, &Spaceship) == NULL && + getIntersectingObjectOfType(*proposedBoundingBox, &Asteroid) == NULL + ); +} + +void createObjects() { + createObject(&Background, getEmptyObjectSpace()); + + createObject(&Spaceship, spaceshipObject); + spaceshipObject->position = (Vec2){EXHAUST_BOUNDING_BOX.size.x, DISPLAY_HEIGHT_IN_PIXELS / 2 - getSize(spaceshipObject).y / 2}; + + createObject(&Astronaut, character); + Rectangle upperFloor = translateRectangle(UPPER_FLOOR_BOUNDING_BOX, spaceshipObject->position); + character->position = add(upperFloor.position, (Vec2){10, 1}); +} + +void generateEvents() { + generate(&Astronaut, generateAstronautPredicate); + generate(&Asteroid, generateAsteroidPredicate); +} diff --git a/christmas/AdAstra/src/objects/event_generator/event_generator.h b/christmas/AdAstra/src/objects/event_generator/event_generator.h new file mode 100644 index 0000000..8c27ea5 --- /dev/null +++ b/christmas/AdAstra/src/objects/event_generator/event_generator.h @@ -0,0 +1,16 @@ +#ifndef EVENT_GENERATOR_H +#define EVENT_GENERATOR_H + +#define MAX_ASTEROID_COUNT 2 + +// For minimizing code size the position of generated objects is decided randomly. +// If it fits then it stays. For each generated object can be a maximum of +// TRY_COUNT tries. +#define TRY_COUNT 16 + +void createObjects(); + +// Generate asteroids and astronaut randomly based on a set of conditions +void generateEvents(); + +#endif diff --git a/christmas/AdAstra/src/objects/object.c b/christmas/AdAstra/src/objects/object.c new file mode 100644 index 0000000..781adef --- /dev/null +++ b/christmas/AdAstra/src/objects/object.c @@ -0,0 +1,41 @@ +#include "object.h" +#include "null.h" + + +Object* createObject(Prototype const* prototype, Object* holder) { + Object empty = {0}; + *holder = empty; + holder->prototype = prototype; + return holder; +} + +void tickObject(Object* object, uint8_t previousFrameTime) { + if (object->prototype != NULL) { + ((TickMethod)pgm_read_word(&object->prototype->tick))(object, previousFrameTime); + } +} + +void drawObject(Object* object, Rectangle compositingWindow) { + if (object->prototype != NULL && areIntersecting(getBoundingBox(object), compositingWindow)) { + ((DrawMethod)pgm_read_word(&object->prototype->draw))(object, compositingWindow); + } +} + +Vec2 getSizeFromPrototype(Prototype const* prototype) { + // required for casting + uint16_t read = pgm_read_word(&prototype->size); + Vec2* v = (Vec2*) &read; + return *v; +} + +Vec2 getSize(Object const* object) { + return getSizeFromPrototype(object->prototype); +} + +void move(Object* object, Vec2 value) { + object->position = add(object->position, value); +} + +Rectangle getBoundingBox(Object const* object) { + return (Rectangle){object->position, getSize(object)}; +} diff --git a/christmas/AdAstra/src/objects/object.h b/christmas/AdAstra/src/objects/object.h new file mode 100644 index 0000000..700afdd --- /dev/null +++ b/christmas/AdAstra/src/objects/object.h @@ -0,0 +1,78 @@ +#ifndef OBJECT_H +#define OBJECT_H + +#include +#include + +#include "../util/rectangle/rectangle.h" + +#include "types/asteroid/asteroid.h" +#include "types/astronaut/astronaut.h" +#include "types/background/background.h" +#include "types/spaceship/spaceship.h" +#include "types/bullet/bullet.h" +#include "types/text/text.h" + +#include "prototype.h" + + +// Objects (they could have been called GameObjects) have a simple +// hierarchy. A prototype/flyweight motivated system is used. +// Each type has some common data and methods which are stored +// in their respective prototype. +// This module provides us with the methods to easily and mostly +// transparently access an object's prototype. + + +typedef union { + struct _background_t background; + struct _spaceship_t spaceship; + struct _astronaut_t astronaut; + struct _asteroid_t asteroid; + struct _bullet_t bullet; + struct _text_t text; +} object_specific_data_t; + + +struct _object_t { + Prototype const* prototype; + Vec2 position; + object_specific_data_t as; +}; + + +// A simplified object intended for persisting its data +// without saving its 16 bit long reference to its prototype +typedef struct { + Vec2 position; + object_specific_data_t as; +} DTO; + + +// Set the prototype of the holder and initialize all the holder's +// vale to zero. Return the freshly updated holder +Object* createObject(Prototype const* prototype, Object* holder); + +// Call the tick function referenced in the object's prototype +// on the object itself +// Object might react to the elapsed time. +// Does nothing when called with NULL. +void tickObject(Object* object, uint8_t previousFrameTime); + +// Call the draw function referenced in the object's prototype +// on the object itself +// Does nothing when called with NULL. +void drawObject(Object* object, Rectangle compositingWindow); + +// Find out the prototype of the object and return the size of that +Vec2 getSize(Object const* object); +Vec2 getSizeFromPrototype(Prototype const* prototype); + +// Move the position of the object by a vector +void move(Object* object, Vec2 value); + +// Get a new rectangle from the objects position and its +// prototype's size +Rectangle getBoundingBox(Object const* object); + +#endif diff --git a/christmas/AdAstra/src/objects/object_container/object_container.c b/christmas/AdAstra/src/objects/object_container/object_container.c new file mode 100644 index 0000000..65178bb --- /dev/null +++ b/christmas/AdAstra/src/objects/object_container/object_container.c @@ -0,0 +1,61 @@ +#include "object_container.h" + +#include "../../driver/redundant_storage/redundant_storage.h" +#include "../event_generator/event_generator.h" + + +Object* getFirstOfType(Prototype const* type) { + for (uint8_t i = 0; i < OBJECT_COUNT; i++) { + if (objects[i].prototype == type) { + return objects + i; + } + } + + return NULL; +} + +uint8_t getCountOf(Prototype const* type) { + uint8_t count = 0; + for (uint8_t i = 0; i < OBJECT_COUNT; i++) { + if (objects[i].prototype == type) { + count++; + } + } + + return count; +} + +Object* getIntersectingObjectOfType(Rectangle boundingBox, Prototype const* type) { + for (uint8_t i = 0; i < OBJECT_COUNT; i++) { + if (objects[i].prototype == type && areIntersecting(boundingBox, getBoundingBox(objects + i))) { + return objects + i; + } + } + + return NULL; +} + +void clearObject(Object* object) { + createObject(NULL, object); +} + +void drawObjects(Rectangle window) { + for (uint8_t i = 0; i < OBJECT_COUNT; i++) { + drawObject(objects + i, window); + } +} + +void tickObjects(uint8_t previousFrameTime) { + for (uint8_t i = 0; i < OBJECT_COUNT; i++) { + tickObject(objects + i, previousFrameTime); + } +} + + +void initializeObjectContainer() { + for (uint8_t i = 0; i < OBJECT_COUNT; i++) { + clearObject(objects + i); + } + + createObjects(); +} diff --git a/christmas/AdAstra/src/objects/object_container/object_container.h b/christmas/AdAstra/src/objects/object_container/object_container.h new file mode 100644 index 0000000..1d3cac9 --- /dev/null +++ b/christmas/AdAstra/src/objects/object_container/object_container.h @@ -0,0 +1,58 @@ +#ifndef OBJECT_HANDLER_H +#define OBJECT_HANDLER_H + +#include +#include + +#include "null.h" + +#include "../object.h" +#include "../../util/rectangle/rectangle.h" +#include "../../util/vec2/vec2.h" + + +// Contain up to OBJECT_COUNT objects. +// Provide the basic functionality to access, search and modify +// these objects. +// For ease of use, there are some convenience global variables for accessing +// objects that are very commonly accessed. + +#define OBJECT_COUNT 10 +#define BACKGROUND_INDEX 0 +#define SPACESHIP_INDEX 1 +#define CHARACTER_INDEX 2 + +#define spaceshipObject (objects + SPACESHIP_INDEX) +#define character (objects + CHARACTER_INDEX) + +// The actual container +Object objects[OBJECT_COUNT]; + +// may return NULL +Object* getFirstOfType(Prototype const* type); +// may return NULL +#define getEmptyObjectSpace() getFirstOfType(NULL) + +// Return the number of objects with a prototype being type +uint8_t getCountOf(Prototype const* type); + +// Return a reference to a random object intersecting boundingBox and having +// a prototype of type +Object* getIntersectingObjectOfType(Rectangle boundingBox, Prototype const* type); + +// Call the tick method of every object +// objects might respond to the elapsed time +void tickObjects(uint8_t previousFrameTime); + +// Call the draw method of every object +void drawObjects(Rectangle window); + +// Delete the object given by its address from objects +// It achieves this by setting the object's prototype to NULL. +void clearObject(Object* object); + +// Delete every object inside of objects +// and create (or load) the starting objects +void initializeObjectContainer(); + +#endif diff --git a/christmas/AdAstra/src/objects/prototype.c b/christmas/AdAstra/src/objects/prototype.c new file mode 100644 index 0000000..0b64dfa --- /dev/null +++ b/christmas/AdAstra/src/objects/prototype.c @@ -0,0 +1,22 @@ +#include "prototype.h" + + +Prototype temp; + +static void loadPrototype(Prototype* prototype) { + /*for (uint8_t i = 0; i < sizeof(prototype); i++) { + ((uint8_t*)(&temp))[i] = pgm_read_byte(prototype + i); + }*/ + + temp = *prototype; +} + +void tickObjectFromPrototype(Object* object) { + loadPrototype(object->prototype); + temp.tick(object); +} + +void drawObjectFromPrototype(Object* object) { + /*loadPrototype(object->prototype); + temp.draw(object);*/ +} diff --git a/christmas/AdAstra/src/objects/prototype.h b/christmas/AdAstra/src/objects/prototype.h new file mode 100644 index 0000000..50cfdfc --- /dev/null +++ b/christmas/AdAstra/src/objects/prototype.h @@ -0,0 +1,28 @@ +#ifndef PROTOTYPE_H +#define PROTOTYPE_H + +#include + +#include "../util/rectangle/rectangle.h" + + +// See more information in object.h + +struct _object_t; +typedef struct _object_t Object; + +// Update the inner state of the given object +// The first argument is the object itself, the second is the elapsed +// time in milliseconds. +typedef void (*TickMethod)(Object*, uint8_t); + +// Draw the given object if its overlapping with the given rectangle +typedef void (*DrawMethod)(Object*, Rectangle); + +typedef struct { + TickMethod tick; + DrawMethod draw; + Vec2 size; +} Prototype; + +#endif diff --git a/christmas/AdAstra/src/objects/types/asteroid/asteroid.c b/christmas/AdAstra/src/objects/types/asteroid/asteroid.c new file mode 100644 index 0000000..fd16802 --- /dev/null +++ b/christmas/AdAstra/src/objects/types/asteroid/asteroid.c @@ -0,0 +1,51 @@ +#include "asteroid.h" + +#include + +#include "../sprites.h" +#include "../../object.h" +#include "../../object_container/object_container.h" +#include "../../../util/vec2/vec2.h" +#include "../../../util/random/random.h" +#include "../../../driver/display/display.h" + + +bool mineAsteroid(Object* asteroid) { + return ++asteroid->as.asteroid.animationFrame == IDLE_FRAME_COUNT; +} + +static void tick(Object* asteroid, __attribute__((unused)) uint8_t previousFrameTime) { + if (asteroid->as.asteroid.animationFrame < IDLE_FRAME_COUNT) { + return; + } + + if (++asteroid->as.asteroid.timeSinceLastFrameChange == EXPLODING_FRAME_CHANGE_INTERVAL) { + if (++asteroid->as.asteroid.animationFrame >= IDLE_FRAME_COUNT + EXPLODING_FRAME_COUNT) { + clearObject(asteroid); + } else { + asteroid->as.asteroid.timeSinceLastFrameChange = 0; + } + } +} + +bool isAsteroidIntersectingWithSpaceship(Object* asteroid, Object* spaceship) { + Rectangle bb = getBoundingBox(asteroid); + startIntersectionTest(bb); + drawObject(asteroid, bb); + drawObject(spaceship, bb); + return endIntersectionTest(); +} + +static void draw(Object* asteroid, Rectangle __attribute__((unused)) compositingWindow) { + drawBitmapFromProgMem( + getBoundingBox(asteroid), + small_asteroid[asteroid->as.asteroid.animationFrame], + asteroid->position.x % 2 + ); +} + +const Prototype Asteroid PROGMEM = { + .tick = tick, + .draw = draw, + .size = ASTEROID_SIZE, +}; diff --git a/christmas/AdAstra/src/objects/types/asteroid/asteroid.h b/christmas/AdAstra/src/objects/types/asteroid/asteroid.h new file mode 100644 index 0000000..176c7f6 --- /dev/null +++ b/christmas/AdAstra/src/objects/types/asteroid/asteroid.h @@ -0,0 +1,25 @@ +#ifndef ASTEROID_H +#define ASTEROID_H + +#include +#include + +#include "../../prototype.h" + +#define ASTEROID_SIZE ((Vec2){8, 8}) +#define IDLE_FRAME_COUNT 4 +#define EXPLODING_FRAME_COUNT 3 +#define EXPLODING_FRAME_CHANGE_INTERVAL 3 + +const Prototype Asteroid; + +bool mineAsteroid(Object* asteroid); +bool isAsteroidIntersectingWithSpaceship(Object* asteroid, Object* spaceship); + +struct _asteroid_t { + bool isMirrored; + uint8_t timeSinceLastFrameChange; + uint8_t animationFrame; +}; + +#endif diff --git a/christmas/AdAstra/src/objects/types/astronaut/astronaut.c b/christmas/AdAstra/src/objects/types/astronaut/astronaut.c new file mode 100644 index 0000000..fd69a19 --- /dev/null +++ b/christmas/AdAstra/src/objects/types/astronaut/astronaut.c @@ -0,0 +1,137 @@ +#include "astronaut.h" + +#include +#include +#include "bitwise.h" +#include "../../../driver/display/display.h" +#include "../../object_container/object_container.h" +#include "../sprites.h" +#include "../../../util/vec2/vec2.h" +#include "../../../util/random/random.h" +#include "../../object.h" + + +#define IS_MIRRORED_BIT 0 +#define IS_CONTROLLING_SPACESHIP_BIT 1 +#define WAS_DOING_ACTION_BIT 2 + +static inline bool getIsMirrored(Object* astronaut) { + return getBit(astronaut->as.astronaut.flags, IS_MIRRORED_BIT); +} + +static inline void setIsMirrored(Object* astronaut, bool value) { + modifyBit(astronaut->as.astronaut.flags, IS_MIRRORED_BIT, value); +} + +static inline bool getWasDoingAction(Object* astronaut) { + return getBit(astronaut->as.astronaut.flags, WAS_DOING_ACTION_BIT); +} + +static inline void setWasDoingAction(Object* astronaut, bool value) { + modifyBit(astronaut->as.astronaut.flags, WAS_DOING_ACTION_BIT, value); +} + + +bool getIsControllingSpaceship(Object* astronaut) { + return getBit(astronaut->as.astronaut.flags, IS_CONTROLLING_SPACESHIP_BIT); +} + +static void setIsControllingSpaceship(Object* astronaut, bool value) { + modifyBit(astronaut->as.astronaut.flags, IS_CONTROLLING_SPACESHIP_BIT, value); +} + +static inline void applyGravity(Object* astronaut) { + if (!isOnLadder(getBoundingBox(astronaut)) && !isBottomOnFloor(getBoundingBox(astronaut))) { + move(astronaut, directions[south]); + } +} + +static void tick(Object* astronaut, uint8_t previousFrameTime) { + if (astronaut->as.astronaut.timeSinceLastAction < TIME_BETWEEN_ACTION_CHANGE) { + astronaut->as.astronaut.timeSinceLastAction += previousFrameTime; + } + + applyGravity(astronaut); +} + +void moveAstronaut(Object* astronaut, Vec2 direction) { + if ( + astronaut->as.astronaut.timeSinceLastAction < TIME_BETWEEN_ACTION_CHANGE + && !getWasDoingAction(astronaut) + ) { + return; + } + astronaut->as.astronaut.timeSinceLastAction = 0; + setWasDoingAction(astronaut, false); + + if (getIsControllingSpaceship(astronaut)) { + moveSpaceship((Vec2){direction.x, 0}); + moveSpaceship((Vec2){0, direction.y}); + } else { + Vec2 proposedPosition = add(astronaut->position, direction); + Rectangle proposedBoundingBox = (Rectangle){proposedPosition, getSize(astronaut)}; + if (isOnboard(proposedBoundingBox)) { + astronaut->position = proposedPosition; + astronaut->as.astronaut.animationFrame = (astronaut->as.astronaut.animationFrame + 1) % MOVE_FRAME_COUNT; + } + + if (direction.x == 0) { + astronaut->as.astronaut.animationFrame = 0; + } + setIsMirrored(astronaut, direction.x < 0); + } +} + +void makeAstronautDoAction(Object* astronaut) { + if ( + astronaut->as.astronaut.timeSinceLastAction < TIME_BETWEEN_ACTION_CHANGE + && getWasDoingAction(astronaut) + ) { + return; + } + astronaut->as.astronaut.timeSinceLastAction = 0; + setWasDoingAction(astronaut, true); + + if (getIsControllingSpaceship(astronaut)) { + setIsControllingSpaceship(astronaut, false); + } else { + Object* text; + switch (getPossibleActionFromSpaceship(astronaut)) { + case shootTurret: + shootTurretOfSpaceship(); + break; + case showLove: + text = getEmptyObjectSpace(); + if (text != NULL) { + if (!createText(text)) { + speedUpText(); + } + } + break; + case repairingSpaceship: + if (spaceshipObject->as.spaceship.healthLoss > 0) { + spaceshipObject->as.spaceship.healthLoss--; + } + break; + case controllingSpaceship: + setIsControllingSpaceship(astronaut, true); + break; + default: + break; + } + } +} + +static void draw(Object* astronaut, __attribute__((unused)) Rectangle compositingWindow) { + drawBitmapFromProgMem( + getBoundingBox(astronaut), + small_character_moving[astronaut->as.astronaut.animationFrame], + getIsMirrored(astronaut) + ); +} + +const Prototype Astronaut PROGMEM = { + .tick = tick, + .draw = draw, + .size = ASTRONAUT_SIZE +}; diff --git a/christmas/AdAstra/src/objects/types/astronaut/astronaut.h b/christmas/AdAstra/src/objects/types/astronaut/astronaut.h new file mode 100644 index 0000000..0a18852 --- /dev/null +++ b/christmas/AdAstra/src/objects/types/astronaut/astronaut.h @@ -0,0 +1,37 @@ +#ifndef ASTRONAUT_H +#define ASTRONAUT_H + +#include "../../prototype.h" +#include + + +#define ASTRONAUT_SIZE ((Vec2){5, 5}) +#define MOVE_FRAME_COUNT 4 + +// Between two consecutive actions (or movements) +// there has to be at least this many milliseconds +#define TIME_BETWEEN_ACTION_CHANGE 50 + +typedef enum { + noAction = 0, + controllingSpaceship, + shootTurret, + showLove, + repairingSpaceship, + ACTION_COUNT +} Action; + + +const Prototype Astronaut; + +struct _astronaut_t { + uint8_t flags; + uint8_t animationFrame; + uint8_t timeSinceLastAction; +}; + +void moveAstronaut(Object* astronaut, Vec2 unitVector); +void makeAstronautDoAction(Object* astronaut); +bool getIsControllingSpaceship(Object* astronaut); + +#endif diff --git a/christmas/AdAstra/src/objects/types/background/background.c b/christmas/AdAstra/src/objects/types/background/background.c new file mode 100644 index 0000000..f7a37dc --- /dev/null +++ b/christmas/AdAstra/src/objects/types/background/background.c @@ -0,0 +1,71 @@ +#include "background.h" + +#include +#include + +#include "../../object.h" +#include "../../../util/rectangle/rectangle.h" +#include "../../../util/random/random.h" +#include "../sprites.h" +#include "../../../driver/display/display.h" + + +typedef struct { + Vec2 position; + uint8_t type; +} Star; + +static Star backgroundStars[STAR_COUNT]; + +static Star createStarOnTheRight() { + return (Star){ + (Vec2){DISPLAY_WIDTH_IN_PIXELS, getRandomNumber() % (DISPLAY_HEIGHT_IN_PIXELS - STAR_SIZE)}, + getRandomNumber() % STAR_SHAPE_COUNT + }; +} + +static void tick(Object* background, __attribute__((unused)) uint8_t previousFrameTime) { + background->as.background.movementState++; + for (uint8_t i = 0; i < STAR_COUNT; i++) { + switch (i % 3) { + case 0: + backgroundStars[i].position.x -= 1; + break; + case 1: + backgroundStars[i].position.x -= background->as.background.movementState & 1; + break; + case 2: + backgroundStars[i].position.x -= ~background->as.background.movementState & 1; + break; + } + if (backgroundStars[i].position.x == -STAR_SIZE) { + backgroundStars[i] = createStarOnTheRight(); + } + } +} + +static void draw(__attribute__((unused)) Object* background, Rectangle compositingWindow) { + for (uint8_t i = 0; i < STAR_COUNT; i++) { + Rectangle starBoundingBox = (Rectangle){backgroundStars[i].position, (Vec2){STAR_SIZE, STAR_SIZE}}; + if (areIntersecting(compositingWindow, starBoundingBox)) { + drawBitmapFromProgMem( + starBoundingBox, + stars[backgroundStars[i].type], + false + ); + } + } +} + +void initializeBackground() { + for (uint8_t i = 0; i < STAR_COUNT; i++) { + backgroundStars[i] = createStarOnTheRight(); + backgroundStars[i].position.x = getRandomNumber(); + } +} + +const Prototype Background PROGMEM = { + .tick = tick, + .draw = draw, + .size = (Vec2){DISPLAY_WIDTH_IN_PIXELS, DISPLAY_HEIGHT_IN_PIXELS} // == WINDOW.size +}; diff --git a/christmas/AdAstra/src/objects/types/background/background.h b/christmas/AdAstra/src/objects/types/background/background.h new file mode 100644 index 0000000..a78acef --- /dev/null +++ b/christmas/AdAstra/src/objects/types/background/background.h @@ -0,0 +1,18 @@ +#ifndef BACKGROUND_H +#define BACKGROUND_H + +#include "../../prototype.h" + + +#define STAR_COUNT 8 +#define STAR_SIZE 3 +#define STAR_SHAPE_COUNT 3 + +const Prototype Background; +struct _background_t { + uint8_t movementState; +}; + +void initializeBackground(); + +#endif \ No newline at end of file diff --git a/christmas/AdAstra/src/objects/types/bullet/bullet.c b/christmas/AdAstra/src/objects/types/bullet/bullet.c new file mode 100644 index 0000000..4237410 --- /dev/null +++ b/christmas/AdAstra/src/objects/types/bullet/bullet.c @@ -0,0 +1,40 @@ +#include "bullet.h" + +#include "../asteroid/asteroid.h" +#include "../spaceship/spaceship.h" +#include "../../object.h" +#include "../../object_container/object_container.h" +#include "null.h" +#include "../../../driver/display/display.h" + + +static void tick(Object* bullet, __attribute__((unused)) uint8_t previousFrameTime) { + if (bullet->as.bullet.wereIntersectingInThePreviousFrame) { + clearObject(bullet); + return; + } + + move(bullet, directions[east]); + + Object* asteroid = getIntersectingObjectOfType(getBoundingBox(bullet), &Asteroid); + if (asteroid != NULL) { + if (mineAsteroid(asteroid) || mineAsteroid(asteroid)) { + onAsteroidMined(); + } + bullet->as.bullet.wereIntersectingInThePreviousFrame = true; + } + + if (!areIntersecting(getBoundingBox(bullet), WINDOW)) { + bullet->as.bullet.wereIntersectingInThePreviousFrame = true; + } +} + +static void draw(Object* bullet, Rectangle __attribute__((unused)) compositingWindow) { + drawFilledRectangle((Rectangle){bullet->position, BULLET_SIZE}, 0, 0xFF); +} + +const Prototype Bullet PROGMEM = { + .tick = tick, + .draw = draw, + .size = BULLET_SIZE, +}; diff --git a/christmas/AdAstra/src/objects/types/bullet/bullet.h b/christmas/AdAstra/src/objects/types/bullet/bullet.h new file mode 100644 index 0000000..bfed188 --- /dev/null +++ b/christmas/AdAstra/src/objects/types/bullet/bullet.h @@ -0,0 +1,16 @@ +#ifndef BULLET_H +#define BULLET_H + +#include "../../prototype.h" +#include + + +#define BULLET_SIZE ((Vec2){5, 1}) + + +const Prototype Bullet; +struct _bullet_t { + bool wereIntersectingInThePreviousFrame; +}; + +#endif diff --git a/christmas/AdAstra/src/objects/types/spaceship/spaceship.c b/christmas/AdAstra/src/objects/types/spaceship/spaceship.c new file mode 100644 index 0000000..2ce819f --- /dev/null +++ b/christmas/AdAstra/src/objects/types/spaceship/spaceship.c @@ -0,0 +1,225 @@ +#include "spaceship.h" + +#include + +#include "../../object.h" +#include "../../../driver/display/display.h" +#include "../astronaut/astronaut.h" +#include "../asteroid/asteroid.h" +#include "../../object_container/object_container.h" +#include "../sprites.h" +#include "../../../util/vec2/vec2.h" +#include "../../../util/random/random.h" +#include "bitwise.h" + + +static uint8_t flickerState; + +SpaceshipPart spaceshipParts[SPACESHIP_PART_COUNT] = { + [TABLE_INDEX] = (SpaceshipPart) { + {{7, 6}, {5, 5}}, + tree[0], + showLove, + false + }, + [BEDS_INDEX] = (SpaceshipPart) { + {{3, 12}, {8, 6}}, + beds[0], + repairingSpaceship, + false + }, + [COMMAND_PANEL_INDEX] = (SpaceshipPart) { + {{26, 7}, {7, 4}}, + NULL, + controllingSpaceship, + true, + }, + [TURRET_CONTROLLER_INDEX] = (SpaceshipPart) { + {{26, 12}, {7, 6}}, + turret_controller[0], + shootTurret, + false + } +}; + + +bool isOnUpperFloor(Rectangle boundingBox) { + return isInside(boundingBox, translateRectangle(UPPER_FLOOR_BOUNDING_BOX, spaceshipObject->position)); +} + +bool isOnLowerFloor(Rectangle boundingBox) { + return isInside(boundingBox, translateRectangle(LOWER_FLOOR_BOUNDING_BOX, spaceshipObject->position)); +} + +bool isBottomOnFloor(Rectangle boundingBox) { + return ( + add(spaceshipObject->position, UPPER_FLOOR_BOUNDING_BOX.position).y + UPPER_FLOOR_BOUNDING_BOX.size.y == boundingBox.position.y + boundingBox.size.y || + add(spaceshipObject->position, LOWER_FLOOR_BOUNDING_BOX.position).y + LOWER_FLOOR_BOUNDING_BOX.size.y == boundingBox.position.y + boundingBox.size.y + ); +} + +bool isOnLadder(Rectangle boundingBox) { + return areIntersecting(boundingBox, translateRectangle(LADDER_BOUNDING_BOX, spaceshipObject->position)); +} + +bool isOnboard(Rectangle boundingBox) { + return isOnLowerFloor(boundingBox) || isOnUpperFloor(boundingBox) || isOnLadder(boundingBox); +} + +Rectangle getBoundingBoxOfSpaceshipPart(SpaceshipPart* part) { + return translateRectangle(part->boundingBox, spaceshipObject->position); +} + +void shootTurretOfSpaceship() { + Object* bullet = getEmptyObjectSpace(); + if (getEmptyObjectSpace() != NULL && spaceshipObject->as.spaceship.healthLoss < MAX_HEALTH - 1) { + createObject(&Bullet, bullet); + bullet->position = add(TURRET_POSITION, spaceshipObject->position); + spaceshipObject->as.spaceship.healthLoss++; + } +} + +void onAsteroidMined() { + switch (++spaceshipObject->as.spaceship.progress) { + case hasBeds: + setBit(spaceshipObject->as.spaceship.activatedParts, BEDS_INDEX); + break; + case hasTurret: + setBit(spaceshipObject->as.spaceship.activatedParts, TURRET_CONTROLLER_INDEX); + break; + case hasTable: + setBit(spaceshipObject->as.spaceship.activatedParts, TABLE_INDEX); + break; + default: + break; + } +} + +void moveSpaceship(Vec2 direction) { + Vec2 proposedPosition = add(spaceshipObject->position, direction); + + if (!isInside(translateRectangle(IN_VIEW_BOUNDING_BOX, proposedPosition), WINDOW)) { + return; + } + + for (uint8_t i = 0; i < OBJECT_COUNT; i++) { + if (objects[i].prototype == &Astronaut) { + move(objects + i, direction); + } + } + + move(spaceshipObject, direction); + + spaceshipObject->position = proposedPosition; + + for (uint8_t i = 0; i < OBJECT_COUNT; i++) { + if (objects[i].prototype == &Asteroid && isAsteroidIntersectingWithSpaceship(objects + i, spaceshipObject)) { + if (mineAsteroid(objects + i)) { + spaceshipObject->as.spaceship.healthLoss += 2; + onAsteroidMined(); + } + } + } +} + +Action getPossibleActionFromSpaceship(Object* astronaut) { + for (uint8_t i = 0; i < SPACESHIP_PART_COUNT; i++) { + SpaceshipPart* part = spaceshipParts + i; + if ( + isSpaceshipPartActivated(part) && areIntersecting(getBoundingBoxOfSpaceshipPart(part), getBoundingBox(astronaut))) { + return part->possibleAction; + } + } + + return noAction; +} + +void tick(Object* spaceship, __attribute__((unused)) uint8_t previousFrameTime) { + flickerState = !flickerState; + if (spaceship->as.spaceship.healthLoss >= MAX_HEALTH) { + spaceship->as.spaceship.healthLoss++; + } +} + +bool isSpaceshipPartActivated(SpaceshipPart* part) { + return part->alwaysActiveDoNotDraw || ((spaceshipObject->as.spaceship.activatedParts >> (part - spaceshipParts)) & 1); +} + +bool isSpaceshipDestroyed() { + return spaceshipObject->as.spaceship.healthLoss >= MAX_HEALTH; +} + +void destroySpaceship() { + spaceshipObject->as.spaceship.healthLoss = MAX_HEALTH; +} + +static inline void drawSpaceshipHealthBar() { + uint8_t actualBarLength = spaceshipObject->as.spaceship.healthLoss * BAR_LENGTH / MAX_HEALTH; + drawFilledRectangle( + (Rectangle){add( + spaceshipObject->position, + (Vec2){BAR_END_POSITION.x - actualBarLength, BAR_END_POSITION.y} + ), (Vec2){actualBarLength, 1}}, 0xFF, 0x00 + ); +} + +static inline void drawSpaceshipParts(Rectangle compositingWindow) { + for (uint8_t i = 0; i < SPACESHIP_PART_COUNT; i++) { + if ( + !(spaceshipParts + i)->alwaysActiveDoNotDraw && + isSpaceshipPartActivated(spaceshipParts + i) && + areIntersecting(compositingWindow, getBoundingBoxOfSpaceshipPart(spaceshipParts + i)) + ) { + drawBitmapFromProgMem( + getBoundingBoxOfSpaceshipPart(spaceshipParts + i), + spaceshipParts[i].sprite, + false + ); + } + } +} + +static inline void drawExhaust(Rectangle compositingWindow) { + Rectangle exhaustRectangle = translateRectangle(EXHAUST_BOUNDING_BOX, spaceshipObject->position); + if ( + areIntersecting(compositingWindow, exhaustRectangle) && + flickerState + ) { + drawBitmapFromProgMem(exhaustRectangle, exhaust[0], false); + } +} + +static inline void drawGlitches() { + for (uint8_t i = 0; i < spaceshipObject->as.spaceship.healthLoss - MAX_HEALTH; i++) { + Rectangle r = translateRectangle( + (Rectangle){(Vec2){getRandomNumber() % SPACESHIP_SIZE.x, getRandomNumber() % SPACESHIP_SIZE.y}, (Vec2){8, 8}}, + spaceshipObject->position + ); + if (areIntersecting(r, WINDOW)) { + drawFilledRectangle(r, 0xFF, 0x00); + } + } +} + +static void draw(Object* spaceship, Rectangle compositingWindow) { + drawBitmapFromProgMem( + getBoundingBox(spaceship), + spaceship_idle[0], + false + ); + + drawSpaceshipParts(compositingWindow); + drawSpaceshipHealthBar(); + + if (spaceship->as.spaceship.healthLoss > MAX_HEALTH) { + drawGlitches(); + } else { + drawExhaust(compositingWindow); + } +} + +const Prototype Spaceship PROGMEM = { + .tick = tick, + .draw = draw, + .size = SPACESHIP_SIZE, +}; diff --git a/christmas/AdAstra/src/objects/types/spaceship/spaceship.h b/christmas/AdAstra/src/objects/types/spaceship/spaceship.h new file mode 100644 index 0000000..2070914 --- /dev/null +++ b/christmas/AdAstra/src/objects/types/spaceship/spaceship.h @@ -0,0 +1,75 @@ +#ifndef SPACESHIP_H +#define SPACESHIP_H + + +#include "../../prototype.h" +#include "../../../util/rectangle/rectangle.h" +#include "../astronaut/astronaut.h" + +#include + +#define SPACESHIP_SIZE ((Vec2){36, 23}) + +#define IN_VIEW_BOUNDING_BOX ((Rectangle){(Vec2){7, 4}, (Vec2){22, 15}}) +#define UPPER_FLOOR_BOUNDING_BOX ((Rectangle){(Vec2){8, 5}, (Vec2){19, 6}}) +#define LOWER_FLOOR_BOUNDING_BOX ((Rectangle){(Vec2){5, 12}, (Vec2){23, 6}}) +#define EXHAUST_BOUNDING_BOX ((Rectangle){(Vec2){-4, 9}, (Vec2){5, 5}}) + +#define TURRET_POSITION ((Vec2){35, 11}) + +#define LADDER_BOUNDING_BOX ((Rectangle){(Vec2){12, 10}, (Vec2){1, 4}}) + +#define BOBBING_INTERVAL 130 +#define SPACESHIP_PART_COUNT 4 + +#define TABLE_INDEX 3 +#define BEDS_INDEX 2 +#define COMMAND_PANEL_INDEX 1 +#define TURRET_CONTROLLER_INDEX 0 + +#define BAR_END_POSITION ((Vec2){33, 11}) +#define BAR_LENGTH 4 +#define MAX_HEALTH 8 + +typedef struct { + Rectangle boundingBox; + uint16_t** sprite; + Action possibleAction; + bool alwaysActiveDoNotDraw; +} SpaceshipPart; + +SpaceshipPart spaceshipParts[SPACESHIP_PART_COUNT]; + +const Prototype Spaceship; + +typedef enum { + hasBeds = 2, + hasTurret = 5, + hasHalfCrew = 8, + hasTable = 12 +} Progress; + +struct _spaceship_t { + uint8_t healthLoss; + uint8_t progress; + uint8_t activatedParts; +}; + +bool isOnboard(Rectangle boundingBox); +void moveSpaceship(Vec2 direction); +Rectangle getBoundingBoxOfSpaceshipPart(SpaceshipPart* part); + +bool isBottomOnFloor(Rectangle boundingBox); +bool isOnUpperFloor(Rectangle boundingBox); +bool isOnLowerFloor(Rectangle boundingBox); +bool isOnLadder(Rectangle boundingBox); +void onAsteroidMined(); +bool isSpaceshipPartActivated(SpaceshipPart* part); + +bool isSpaceshipDestroyed(); +void destroySpaceship(); + +void shootTurretOfSpaceship(); +Action getPossibleActionFromSpaceship(Object* astronaut); + +#endif diff --git a/christmas/AdAstra/src/objects/types/sprites.c b/christmas/AdAstra/src/objects/types/sprites.c new file mode 100644 index 0000000..a64db74 --- /dev/null +++ b/christmas/AdAstra/src/objects/types/sprites.c @@ -0,0 +1,16 @@ +#include "sprites.h" + +#include + + +// AUTO-GENERATED + +const uint16_t beds[1][8][1] PROGMEM = {{{0x707},{0xc0c},{0x2424},{0x2424},{0x2424},{0x2424},{0x2424},{0x2424}}}; +const uint16_t exhaust[1][5][1] PROGMEM = {{{0x404},{0xe0e},{0xe0e},{0x1f1f},{0x404}}}; +const uint16_t font[50][4][1] PROGMEM = {{{0xff78},{0xff14},{0xff14},{0xff78}},{{0xff78},{0xff14},{0xff14},{0xff79}},{{0xff7c},{0xff54},{0xff54},{0xff28}},{{0xff38},{0xff44},{0xff44},{0xff28}},{{0xff7c},{0xff44},{0xff44},{0xff38}},{{0xff7c},{0xff54},{0xff54},{0xff44}},{{0xff7c},{0xff54},{0xff55},{0xff44}},{{0xff7c},{0xff14},{0xff14},{0xff04}},{{0xff38},{0xff44},{0xff54},{0xff30}},{{0xff7c},{0xff10},{0xff10},{0xff7c}},{{0xff44},{0xff7c},{0xff44},{0xff44}},{{0xff44},{0xff7c},{0xff45},{0xff44}},{{0xff20},{0xff40},{0xff40},{0xff3c}},{{0xff7c},{0xff10},{0xff28},{0xff44}},{{0xff7c},{0xff40},{0xff40},{0xff40}},{{0xff7c},{0xff0c},{0xff1c},{0xff7c}},{{0xff7c},{0xff08},{0xff30},{0xff7c}},{{0xff38},{0xff44},{0xff44},{0xff38}},{{0xff38},{0xff44},{0xff45},{0xff38}},{{0xff39},{0xff44},{0xff44},{0xff39}},{{0xff39},{0xff45},{0xff45},{0xff39}},{{0xff7c},{0xff14},{0xff14},{0xff08}},{{0xff18},{0xff24},{0xff24},{0xff58}},{{0xff7c},{0xff14},{0xff14},{0xff68}},{{0xff48},{0xff54},{0xff54},{0xff24}},{{0xff04},{0xff7c},{0xff04},{0xff04}},{{0xff7c},{0xff40},{0xff40},{0xff7c}},{{0xff7c},{0xff40},{0xff41},{0xff7c}},{{0xff7d},{0xff40},{0xff40},{0xff7d}},{{0xff7d},{0xff41},{0xff41},{0xff7d}},{{0xff3c},{0xff40},{0xff40},{0xff3c}},{{0xff7c},{0xff60},{0xff70},{0xff7c}},{{0xff44},{0xff38},{0xff38},{0xff44}},{{0xff1c},{0xff70},{0xff10},{0xff1c}},{{0xff64},{0xff54},{0xff54},{0xff4c}},{{0xff7c},{0xff44},{0xff44},{0xff7c}},{{0xff08},{0xff44},{0xff7c},{0xff40}},{{0xff4c},{0xff64},{0xff54},{0xff4c}},{{0xff44},{0xff54},{0xff54},{0xff7c}},{{0xff3c},{0xff20},{0xff70},{0xff20}},{{0xff5c},{0xff54},{0xff54},{0xff24}},{{0xff7c},{0xff54},{0xff54},{0xff74}},{{0xff04},{0xff64},{0xff14},{0xff0c}},{{0xff7c},{0xff54},{0xff54},{0xff7c}},{{0xff5c},{0xff54},{0xff54},{0xff7c}},{{0xff00},{0xffc0},{0xff00},{0xff00}},{{0xff40},{0xff00},{0xff00},{0xff00}},{{0xff5c},{0xff00},{0xff00},{0xff00}},{{0xff08},{0xffa4},{0xff14},{0xff08}},{{0xff00},{0xff00},{0xff00},{0xff00}}}; +const uint16_t small_asteroid[7][8][1] PROGMEM = {{{0x1c1c},{0x7e7e},{0xfef2},{0xfffb},{0xffff},{0xffdf},{0x7e7e},{0x3c3c}},{{0x0},{0x3c3c},{0x7e72},{0x7e7a},{0x7e7e},{0x7e5e},{0x3c3c},{0x0}},{{0x0},{0x0},{0x3030},{0x7878},{0x7c7c},{0x7c5c},{0x3838},{0x0}},{{0x0},{0x0},{0x3030},{0x3838},{0x3838},{0x1010},{0x0},{0x0}},{{0x0},{0x3030},{0x4848},{0x4444},{0x4444},{0x2828},{0x1010},{0x0}},{{0x2828},{0x8484},{0x8080},{0x0},{0x8282},{0x4444},{0x2828},{0x0}},{{0x202},{0x0},{0x0},{0x0},{0x0},{0x0},{0x8181},{0x4242}}}; +const uint16_t small_character_moving[4][5][1] PROGMEM = {{{0x606},{0x1f1d},{0xf0b},{0x1f1d},{0x606}},{{0x606},{0x1f1d},{0xf0b},{0xf0d},{0x1616}},{{0x606},{0x1f1d},{0xf0b},{0x1f1d},{0x606}},{{0x606},{0xf0d},{0x1f1b},{0x1f1d},{0x606}}}; +const uint16_t spaceship_idle[1][36][3] PROGMEM = {{{0x404,0x1414,0x1010},{0x404,0x3e3e,0x1010},{0xceca,0xffff,0x3828},{0xee6a,0xff8a,0x3929},{0xff3b,0xff09,0x7f6f},{0xff91,0xff08,0x7f44},{0xff51,0xff08,0x7f44},{0xff31,0xff08,0x7f44},{0xff1f,0xff08,0x7f7c},{0xf111,0xff08,0x4744},{0xf010,0xff08,0x704},{0xf010,0xfff8,0x707},{0xf010,0xff28,0x705},{0xf010,0xfff8,0x707},{0xf010,0xff08,0x704},{0xf010,0xff08,0x704},{0xf010,0xff08,0x704},{0xf010,0xff08,0x704},{0xf414,0xff08,0x1714},{0xf414,0xff08,0x1714},{0xfc1c,0xff08,0x1f1c},{0xfc1c,0xff08,0x1f1c},{0xf818,0xff08,0xf0c},{0xf010,0xff08,0x704},{0xf010,0xff08,0x704},{0xf010,0xff08,0x704},{0xf010,0xff0c,0x704},{0xf010,0xff0a,0x704},{0xf0b0,0xff1f,0x706},{0xe020,0xff1c,0x302},{0xe060,0xff1c,0x303},{0xc0c0,0xff9c,0x101},{0x8080,0xffdd,0x0},{0x0,0x7f7f,0x0},{0x0,0x1c1c,0x0},{0x0,0x808,0x0}}}; +const uint16_t stars[3][3][1] PROGMEM = {{{0x202},{0x707},{0x202}},{{0x505},{0x202},{0x505}},{{0x0},{0x303},{0x303}}}; +const uint16_t tree[1][5][1] PROGMEM = {{{0x808},{0xa0a},{0x1515},{0xa0a},{0x808}}}; +const uint16_t turret_controller[1][7][1] PROGMEM = {{{0x3030},{0x808},{0xf0f},{0x101},{0x101},{0x101},{0x101}}}; diff --git a/christmas/AdAstra/src/objects/types/sprites.h b/christmas/AdAstra/src/objects/types/sprites.h new file mode 100644 index 0000000..5cbe71d --- /dev/null +++ b/christmas/AdAstra/src/objects/types/sprites.h @@ -0,0 +1,19 @@ +#ifndef SPRITES_H +#define SPRITES_H + +#include + + +// AUTO-GENERATED + +const uint16_t beds[1][8][1]; +const uint16_t exhaust[1][5][1]; +const uint16_t font[50][4][1]; +const uint16_t small_asteroid[7][8][1]; +const uint16_t small_character_moving[4][5][1]; +const uint16_t spaceship_idle[1][36][3]; +const uint16_t stars[3][3][1]; +const uint16_t tree[1][5][1]; +const uint16_t turret_controller[1][7][1]; + +#endif diff --git a/christmas/AdAstra/src/objects/types/text/text.c b/christmas/AdAstra/src/objects/types/text/text.c new file mode 100644 index 0000000..1a4f05a --- /dev/null +++ b/christmas/AdAstra/src/objects/types/text/text.c @@ -0,0 +1,114 @@ +#include "text.h" + +#include + +#include "../asteroid/asteroid.h" +#include "../spaceship/spaceship.h" +#include "../sprites.h" +#include "../../object.h" +#include "../../object_container/object_container.h" +#include "null.h" +#include "math.h" +#include "../../../driver/display/display.h" + +#include +#define STRING_TERMINATOR 255 +#define CHARACTER_WIDTH 4 + +static bool canCreateNext = true; +static int8_t previousTextIndex = -1; +static bool isSpedUp = false; + +bool createText(Object* object) { + if (!canCreateNext) { + return false; + } + + createObject(&Text, object); + object->as.text.xPosition = DISPLAY_WIDTH_IN_PIXELS; + object->as.text.hasSetCanCreate = false; + object->position = (Vec2){0, 0}; + previousTextIndex++; + isSpedUp = false; + uint8_t textCount = 0; + for (uint16_t i = 0; i < 512; i++) { + if (textCount == previousTextIndex) { + if (eeprom_read_byte(i) == STRING_TERMINATOR) { + previousTextIndex = 0; + object->as.text.textStartIndex = 0; + } else { + object->as.text.textStartIndex = i; + } + canCreateNext = false; + return; + } + + if (eeprom_read_byte(i) == STRING_TERMINATOR) { + textCount++; + } + } + + return true; +} + +void speedUpText() { + isSpedUp = true; +} + +static uint8_t getTextLength(Object* text) { + for (uint8_t i = 0; i < 255; i++) { + if (eeprom_read_byte(text->as.text.textStartIndex + i) == STRING_TERMINATOR) { + return i; + } + } + + return 0; +} + +static void tick(Object* text, __attribute__((unused)) uint8_t previousFrameTime) { + if (++text->as.text.timeSinceLastShift > 2 || isSpedUp) { + text->as.text.xPosition--; + text->as.text.timeSinceLastShift = 0; + } + + if ( + !text->as.text.hasSetCanCreate + && getTextLength(text) * (CHARACTER_WIDTH + 1) + text->as.text.xPosition < DISPLAY_WIDTH_IN_PIXELS - CHARACTER_WIDTH - 1 + ) { + canCreateNext = true; + text->as.text.hasSetCanCreate = true; + } + + if (getTextLength(text) * (CHARACTER_WIDTH + 1) < -text->as.text.xPosition) { + clearObject(text); + } +} + +static void draw(Object* text, Rectangle __attribute__((unused)) compositingWindow) { + uint8_t indexOfFirstVisible = max(0, -text->as.text.xPosition / (CHARACTER_WIDTH + 1)); + for (uint8_t i = indexOfFirstVisible; i < indexOfFirstVisible + DISPLAY_WIDTH_IN_PIXELS / (CHARACTER_WIDTH + 1) + 2; i++) { + uint8_t letter = eeprom_read_byte(text->as.text.textStartIndex + i); + if (letter == STRING_TERMINATOR) { + return; + } + + drawBitmapFromProgMem( + (Rectangle){(Vec2){text->as.text.xPosition + i * (CHARACTER_WIDTH + 1), 0}, (Vec2){4, 8}}, + font[letter], + false + ); + + drawFilledRectangle( + (Rectangle){(Vec2){text->as.text.xPosition + i * (CHARACTER_WIDTH + 1) + CHARACTER_WIDTH, 0}, + (Vec2){1, 8}}, + 0xFF, + 0x00 + ); + } +} + +const Prototype Text PROGMEM = { + .tick = tick, + .draw = draw, + .size = TEXT_SIZE, +}; diff --git a/christmas/AdAstra/src/objects/types/text/text.h b/christmas/AdAstra/src/objects/types/text/text.h new file mode 100644 index 0000000..9847c3c --- /dev/null +++ b/christmas/AdAstra/src/objects/types/text/text.h @@ -0,0 +1,21 @@ +#ifndef TEXT_H +#define TEXT_H + +#include "../../prototype.h" +#include + + +#define TEXT_SIZE ((Vec2){64, 8}) + +const Prototype Text; +struct _text_t { + int16_t xPosition; + uint16_t textStartIndex; + uint8_t timeSinceLastShift; + bool hasSetCanCreate; +}; + +bool createText(Object* position); +void speedUpText(); + +#endif diff --git a/christmas/AdAstra/src/objects/types/text/texts.c b/christmas/AdAstra/src/objects/types/text/texts.c new file mode 100644 index 0000000..f586358 --- /dev/null +++ b/christmas/AdAstra/src/objects/types/text/texts.c @@ -0,0 +1,8 @@ +#include "texts.h" + +#include + + +// AUTO-GENERATED + +const uint8_t texts[385] EEMEM = {24, 34, 10, 0, 45, 2, 0, 14, 1, 34, 24, 47, 255, 2, 17, 14, 4, 17, 8, 49, 13, 0, 23, 1, 3, 24, 17, 16, 33, 25, 49, 13, 11, 30, 1, 16, 17, 13, 47, 255, 30, 10, 24, 34, 17, 16, 25, 49, 15, 1, 24, 25, 49, 10, 24, 49, 24, 34, 5, 23, 5, 25, 16, 6, 13, 49, 15, 17, 16, 4, 0, 16, 10, 46, 255, 9, 0, 2, 1, 23, 49, 23, 19, 30, 10, 4, 5, 2, 2, 45, 4, 5, 49, 0, 16, 16, 1, 14, 49, 24, 29, 23, 29, 2, 2, 49, 30, 17, 14, 25, 49, 0, 34, 49, 5, 8, 33, 16, 33, 1, 23, 10, 49, 13, 0, 14, 0, 16, 4, 26, 16, 13, 46, 255, 19, 23, 19, 15, 49, 30, 17, 14, 25, 49, 25, 6, 8, 5, 4, 49, 15, 5, 8, 10, 24, 15, 5, 23, 16, 10, 46, 255, 0, 49, 13, 23, 5, 0, 25, 10, 30, 10, 25, 1, 24, 17, 4, 49, 6, 24, 49, 19, 24, 24, 34, 5, 24, 34, 5, 4, 5, 25, 25, 24, 6, 8, 5, 4, 49, 10, 16, 24, 21, 10, 23, 1, 14, 18, 46, 255, 25, 27, 14, 34, 1, 24, 49, 16, 6, 14, 13, 28, 14, 49, 24, 17, 13, 26, 16, 13, 49, 21, 6, 14, 4, 0, 13, 6, 21, 5, 49, 14, 5, 9, 5, 25, 16, 6, 14, 46, 255, 19, 24, 24, 34, 5, 24, 24, 6, 8, 6, 2, 5, 16, 45, 16, 6, 14, 13, 28, 14, 5, 4, 49, 13, 10, 3, 24, 10, 25, 49, 24, 34, 17, 15, 17, 23, 27, 2, 2, 49, 14, 5, 16, 16, 5, 49, 0, 34, 49, 6, 14, 5, 25, 46, 255, 23, 5, 15, 6, 14, 5, 15, 49, 5, 34, 25, 49, 25, 5, 49, 10, 24, 49, 25, 26, 4, 17, 4, 49, 15, 0, 8, 0, 4, 23, 18, 14, 46, 255, 30, 1, 23, 17, 15, 45, 9, 17, 8, 33, 49, 15, 10, 9, 0, 15, 0, 23, 0, 2, 2, 49, 25, 0, 14, 1, 14, 13, 17, 34, 34, 26, 16, 13, 46, 255, 0, 16, 4, 23, 10, 24, 255, 255, 255}; diff --git a/christmas/AdAstra/src/objects/types/text/texts.h b/christmas/AdAstra/src/objects/types/text/texts.h new file mode 100644 index 0000000..375ffc6 --- /dev/null +++ b/christmas/AdAstra/src/objects/types/text/texts.h @@ -0,0 +1,11 @@ +#ifndef TEXTS_H +#define TEXTS_H + +#include + + +// AUTO-GENERATED + +const uint8_t texts[385]; + +#endif diff --git a/christmas/AdAstra/src/util/random/random.c b/christmas/AdAstra/src/util/random/random.c new file mode 100644 index 0000000..50cce21 --- /dev/null +++ b/christmas/AdAstra/src/util/random/random.c @@ -0,0 +1,14 @@ +#include "random.h" + + +static uint16_t currentValue = SEED; + +static uint16_t getRandom16bitNumberModuloPrime() { + uint16_t bit = currentValue ^ (currentValue >> 2) ^ (currentValue >> 3) ^ (currentValue >> 5); + currentValue = (currentValue >> 1) | (bit << 15); + return currentValue % 1031; +} + +uint8_t getRandomNumber() { + return (uint8_t)(getRandom16bitNumberModuloPrime() ^ getRandom16bitNumberModuloPrime()); +} diff --git a/christmas/AdAstra/src/util/random/random.h b/christmas/AdAstra/src/util/random/random.h new file mode 100644 index 0000000..ea00ab8 --- /dev/null +++ b/christmas/AdAstra/src/util/random/random.h @@ -0,0 +1,14 @@ +#ifndef RANDOM_H +#define RANDOM_H + +#include + + +// Mustn't be zero, should be lower than 65535 +#define SEED 42 + +// Simple LFSR with some improvements to enhance distribution +// while maintaining short execution time +uint8_t getRandomNumber(); + +#endif diff --git a/christmas/AdAstra/src/util/rectangle/rectangle.c b/christmas/AdAstra/src/util/rectangle/rectangle.c new file mode 100644 index 0000000..552eb03 --- /dev/null +++ b/christmas/AdAstra/src/util/rectangle/rectangle.c @@ -0,0 +1,34 @@ +#include "rectangle.h" + + +bool areIntersecting(Rectangle r1, Rectangle r2) { + return ( + r1.position.x < r2.position.x + r2.size.x && + r1.position.x + r1.size.x > r2.position.x && + r1.position.y < r2.position.y + r2.size.y && + r1.position.y + r1.size.y > r2.position.y + ); +} + +bool isInside(Rectangle inner, Rectangle outer) { + return ( + outer.position.x <= inner.position.x && + inner.position.x + inner.size.x <= outer.position.x + outer.size.x && + outer.position.y <= inner.position.y && + inner.position.y + inner.size.y <= outer.position.y + outer.size.y + ); +} + +Vec2 getCenter(Rectangle r) { + return (Vec2) { + r.position.x + r.size.x / 2, + r.position.y + r.size.y / 2 + }; +} + +Rectangle translateRectangle(Rectangle r, Vec2 translate) { + return (Rectangle) { + add(r.position, translate), + r.size + }; +} diff --git a/christmas/AdAstra/src/util/rectangle/rectangle.h b/christmas/AdAstra/src/util/rectangle/rectangle.h new file mode 100644 index 0000000..7e94b07 --- /dev/null +++ b/christmas/AdAstra/src/util/rectangle/rectangle.h @@ -0,0 +1,26 @@ +#ifndef RECTANGLE_H +#define RECTANGLE_H + +#include + +#include "../vec2/vec2.h" + + +typedef struct { + Vec2 position; + Vec2 size; +} Rectangle; + + +bool areIntersecting(Rectangle r1, Rectangle r2); + +// Return true only if inner is fully inside of outer +bool isInside(Rectangle inner, Rectangle outer); + +// Return the geometrical middle point of the given rectangle +Vec2 getCenter(Rectangle r); + +// Return a new rectangle shifted by vector translate +Rectangle translateRectangle(Rectangle r, Vec2 translate); + +#endif diff --git a/christmas/AdAstra/src/util/vec2/vec2.c b/christmas/AdAstra/src/util/vec2/vec2.c new file mode 100644 index 0000000..4a8351b --- /dev/null +++ b/christmas/AdAstra/src/util/vec2/vec2.c @@ -0,0 +1,24 @@ +#include "vec2.h" + + +const Vec2 directions[] = { + [north] = (Vec2){0, -1}, + [west] = (Vec2){-1, 0}, + [south] = (Vec2){0, 1}, + [east] = (Vec2){1, 0} +}; + +Vec2 add(Vec2 v1, Vec2 v2) { + return (Vec2){v1.x + v2.x, v1.y + v2.y}; +} + +Vec2 substract(Vec2 v1, Vec2 v2) { + return (Vec2){v1.x - v2.x, v1.y - v2.y}; +} + +Vec2 clampVec2(Vec2 v) { + return (Vec2){ + v.x == 0 ? 0 : (v.x > 0 ? 1 : -1), + v.y == 0 ? 0 : (v.y > 0 ? 1 : -1) + }; +} diff --git a/christmas/AdAstra/src/util/vec2/vec2.h b/christmas/AdAstra/src/util/vec2/vec2.h new file mode 100644 index 0000000..a8cf263 --- /dev/null +++ b/christmas/AdAstra/src/util/vec2/vec2.h @@ -0,0 +1,26 @@ +#ifndef VEC2_H +#define VEC2_H + +#include + + +typedef struct { + int8_t x; + int8_t y; +} Vec2; + +typedef enum { + north, west, south, east +} Direction; + +// The array directions can be indexed by a Direction and +// it contains vectors pointing into that direction. +const Vec2 directions[4]; + +Vec2 add(Vec2 v1, Vec2 v2); +Vec2 substract(Vec2 v1, Vec2 v2); + +// Return new vector with ll components between -1 and 1 (inclusive) +Vec2 clampVec2(Vec2 vector); + +#endif diff --git a/christmas/Felhasználói dokumentáció.docx b/christmas/Felhasználói dokumentáció.docx new file mode 100644 index 0000000000000000000000000000000000000000..83e1895a6d794491788592c8f6e15128e97a6b97 GIT binary patch literal 229528 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 z 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,_M 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

d$P(k;cZ1VpQd8Ll88}i6I`70C5C5 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

@V0cgsMa>;V2) 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 UoaK0V1R;W8EG8xyRavb617vd>o&W#< literal 0 HcmV?d00001 diff --git a/christmas/text_generator/README.md b/christmas/text_generator/README.md new file mode 100644 index 0000000..1bbaaa3 --- /dev/null +++ b/christmas/text_generator/README.md @@ -0,0 +1,15 @@ +# Sprite generator + +## Install + +- Install Python 3.5 or later +- Execute `pip install -r requirements.txt` + +## Use + +- Using [Piskel](https://www.piskelapp.com/) + - draw the sprites + - export them in `zip` format (it's a .zip containing .png files) +- Place the files inside the [spritesheets](spritesheets) folder +- Execute `python main.py` +- The output is automatically placed in the [output](output) folder diff --git a/christmas/text_generator/input/.vscode/settings.json b/christmas/text_generator/input/.vscode/settings.json new file mode 100644 index 0000000..644c232 --- /dev/null +++ b/christmas/text_generator/input/.vscode/settings.json @@ -0,0 +1,14 @@ +{ + "spellright.language": [ + "en", + "hu" + ], + "spellright.documentTypes": [ + "markdown", + "latex", + "plaintext" + ], + "cSpell.enableFiletypes": [ + "!plaintext" + ] +} \ No newline at end of file diff --git a/christmas/text_generator/input/adam.txt b/christmas/text_generator/input/adam.txt new file mode 100644 index 0000000..499e415 --- /dev/null +++ b/christmas/text_generator/input/adam.txt @@ -0,0 +1,13 @@ +Szia, Ádám! +Boldog karácsonyt kívánok! +Viszont mást is szeretnék mondani. +Most egy kicsit még távolabb fogunk kerülni egymástól. +Persze biztos vagyok benne, hogy ezután is tartani fogjuk a kapcsolatot. +Viszont jó pillanatnak érzem a mostanit arra, hogy köszönetet mondjak. +Köszönöm az együtt töltött időnket. +Köszönöm, hogy más ember lettem melletted. +Ebben neked is részed volt. +Összességében, nélküled kicsit szomorúbb lenne az élet. +Remélem ezt te is tudod magadról. +Várom, hogy mihamarabb találkozzunk. +Andris \ No newline at end of file diff --git a/christmas/text_generator/input/apa.txt b/christmas/text_generator/input/apa.txt new file mode 100644 index 0000000..6d51cb4 --- /dev/null +++ b/christmas/text_generator/input/apa.txt @@ -0,0 +1,11 @@ +Szia, Apa! +Boldog karácsonyt kívánok! +Viszont mást is szeretnék mondani. +Szeretném megköszönni azt a számtalan segítséget, amit tőled kaptam. +Köszönöm, hogy mindig támogattál és motiváltál. +Köszönöm, hogy mindig mögöttem álltál. +Nélküled most biztosan nem tartanék itt. +Ha ezt nehezen is fejeztem ki, de mindig fontos voltál nekem. +Összességében, nélküled kicsit szomorúbb lenne az élet. +Remélem ezt te is tudod magadról. +Andris diff --git a/christmas/text_generator/input/balazs.txt b/christmas/text_generator/input/balazs.txt new file mode 100644 index 0000000..4918b23 --- /dev/null +++ b/christmas/text_generator/input/balazs.txt @@ -0,0 +1,11 @@ +Szia, Balázs! +Boldog karácsonyt kívánok! +Viszont mást is szeretnék mondani. +Habár rövidebb, de annál sűrűbb volt az egynyári kalandunk. +Öröm volt téged megismerni. +A kreativitásod és összeszedettséged inspiráló. +Túlzás nélkül sokunk példaképe lehetnél. +Összességében, nélküled kicsit szomorúbb lenne az élet. +Remélem ezt te is tudod magadról. +Várom, hogy mihamarabb találkozzunk. +Andris diff --git a/christmas/text_generator/input/oliver.txt b/christmas/text_generator/input/oliver.txt new file mode 100644 index 0000000..e5f20d7 --- /dev/null +++ b/christmas/text_generator/input/oliver.txt @@ -0,0 +1,12 @@ +Szia, Olivér! +Boldog karácsonyt kívánok! +Viszont mást is szeretnék mondani. +Jó pillanatnak érzem a mostanit arra, hogy köszönetet mondjak. +A barátságod, segítséged és humorod meghatározta az elmúlt éveimet. +Ha nem is gondolod így, de nagy hatással voltál rám. +Az elhivatottságod és kitartásod mindig inspirált. +Te vagy az a barát, akit mindenki szeretne. +Összességében, nélküled kicsit szomorúbb lenne az élet. +Remélem ezt te is tudod magadról. +Várom, hogy mihamarabb találkozzunk. +Andris diff --git a/christmas/text_generator/main.py b/christmas/text_generator/main.py new file mode 100644 index 0000000..24466a1 --- /dev/null +++ b/christmas/text_generator/main.py @@ -0,0 +1,121 @@ +import io +import os +import zipfile +from math import ceil +from sys import argv +from typing import Tuple + +from PIL import Image + +c_header = """#include "texts.h" + +#include + + +// AUTO-GENERATED + +""" + +h_header = """#ifndef TEXTS_H +#define TEXTS_H + +#include + + +// AUTO-GENERATED + +""" + +h_footer = """ +#endif +""" + +letters = [ + "a", + "á", + "b", + "c", + "d", + "e", + "é", + "f", + "g", + "h", + "i", + "í", + "j", + "k", + "l", + "m", + "n", + "o", + "ó", + "ö", + "ő", + "p", + "q", + "r", + "s", + "t", + "u", + "ú", + "ü", + "ű", + "v", + "w", + "x", + "y", + "z", + "0", + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "8", + "9", + ",", + ".", + "!", + "?", + " ", +] + + +def generate(input_text: str) -> Tuple[str, str]: + indices = [] + for line in input_text.split("\n"): + for char in line.strip().lower().replace(", ", ","): + indices.append(letters.index(char)) + indices.append(255) + indices.append(255) + + if len(indices) > 512: + print(f"Input is too long ({len(indices)} > 512)") + exit() + + output_h = h_header + f"const uint8_t texts[{len(indices)}];\n" + h_footer + output_c = c_header + f"const uint8_t texts[{len(indices)}] EEMEM = {{" + + output_c += ", ".join(str(i) for i in indices) + output_c += "};\n" + + return output_h, output_c + + +if __name__ == "__main__": + if len(argv) == 1: + print("Specify an input file") + exit() + + with open(argv[1], "r", encoding="utf-8") as f: + input_text = f.read() + + dot_h, dot_c = generate(input_text) + + with open("output/texts.h", "w+") as f: + f.write(dot_h) + with open("output/texts.c", "w+") as f: + f.write(dot_c) diff --git a/christmas/text_generator/requirements.txt b/christmas/text_generator/requirements.txt new file mode 100644 index 0000000..1c12e1b --- /dev/null +++ b/christmas/text_generator/requirements.txt @@ -0,0 +1 @@ +Pillow==8.0.1