← Back to the short version

🦆 Duckdoku: the full day-by-day journal

Art generation, at a glance: all Duckdoku art was made with OpenAI's image API (gpt-image-2 for the main art, gpt-image-1 for a couple of later images), medium quality, generated close to 1080p (1920×1088, the nearest size the tool allows). Images came back as sprite sheets — several poses in one picture — and were cut into the individual images the game uses. On Day 9 I re-ran the same sheets at low quality to compare price and look.
Sound and visual effect packages used (all from the Unity Asset Store, plus a couple of custom lines):

Example prompts I used

These are real prompts, copied straight from my own notes, not re-written for this page.

Sheet 1 — duck faces (8 poses, one sheet)

A game sprite sheet on a perfectly flat, solid pure magenta (#FF00FF) background, 1920x1088, for a cute mobile puzzle game called Duckdoku. A 4 columns x 2 rows grid of 8 separate poses of the SAME character head, each centered in its own equal cell with wide empty magenta space between them, nothing touching, no text, no labels, no borders. Character: a chubby, round, fluffy 3D-rendered duck HEAD (head only, no body). Soft glossy Pixar-style 3D render, smooth clay-like materials, soft studio lighting, clean edges. White-and-butter-yellow feathers, a small orange flat beak, big round glossy dark eyes with white highlights, tiny cheek blush, small feather tuft on top. Cute, friendly, slightly goofy. Exactly the same character and same size in every cell, the head fills about 70% of the cell height. Poses, left to right, top row then bottom row: 1. Looking straight at the viewer, calm, mouth closed. 2. Eyes looking to the top-left, head slightly turned to the top-left. 3. Eyes looking to the top-right, head slightly turned to the top-right. 4. Winking at the viewer with the LEFT eye closed, tiny happy smile. 5. Winking at the viewer with the RIGHT eye closed, tiny happy smile. 6. Very happy, eyes closed in joy, beak open in a smile. 7. Sad and worried, eyes looking down, small tear. 8. Sleepy, eyes half closed.

The flat magenta background was a trick: my cutting script turned every magenta pixel transparent automatically, so I never had to manually erase a background.

Logo and splash sheet

Game sprite sheet on a perfectly flat solid pure magenta (#FF00FF) background, 1920x1088, for the cute mobile puzzle game Duckdoku. Every item sits in its own equal grid cell with wide empty magenta space around it, nothing touching or overlapping, no text unless stated, no borders, no drop shadow onto the background. Art style: glossy soft 3D-rendered Pixar-like look, smooth clay-like materials, soft studio lighting, warm cozy palette (cream, orange #F0931F, soft yellow, teal, pink, deep brown). The duck must be EXACTLY the same character as in the attached reference sheet: chubby round fluffy white-and-butter-yellow duck, small orange flat beak, big glossy dark eyes, pink cheek blush, small feather tuft on top. A logo and splash sheet: on the left, a large 3D bubble-letter logo reading exactly DUCKDOKU in glossy orange (#F0931F) and cream letters with a subtle thick outline, where the letter O in DUCK has a little duck head peeking out of it; below the logo a small tagline reading exactly "Think. Place. Solve." in soft brown. On the right, a tall wide splash illustration of the duck sitting happily on a small rounded 4x4 coloured puzzle grid (teal, orange, pink, green tiles) with sparkles.

App icon (later, 3D version)

App icon, square, 1024x1024, full bleed, no border, no text. Background: a 3D glossy diagonal split, top-right a glossy raised orange 3D panel, bottom-left a glossy raised deep purple 3D panel, both with visible thick rounded 3D grid lines like raised sudoku tile borders and soft drop shadows between panels, giving a real depth and bevel look. In the top-right orange panel a small chunky 3D white rounded X-shaped tile icon with its own drop shadow, sitting slightly above the surface. Centered and large, covering most of the icon: a fully 3D rendered pixar-style baby duck head, realistic soft fluffy fur shading, glossy big brown eyes with catchlight, glossy orange beak with a warm smile, soft rim light and ambient occlusion, the duck sits forward with a drop shadow onto the panels behind it, strong sense of 3D volume and depth like a modern 3D mobile game icon. Bright, polished, high-detail 3D render, no flat shapes, no text, no watermark.

Featured graphic (Play Store banner)

Mobile game store featured graphic, 1536x1024 landscape banner. Warm cream background with soft orange glow. Top-left game logo text: bold rounded playful cartoon letters spelling DUCKDOKU, yellow and orange colors with a thin brown outline, small star decoration near the logo. Center-left: a bright colorful sudoku-style grid board tilted slightly, made of rounded square tiles in soft pastel colors (blue, yellow, pink, teal, purple, green), some tiles have a white X mark, a couple of tiles have a small cute cartoon duck face sticker on them. Right side: one large adorable 3D pixar-style baby duck character, yellow fluffy feathers, big brown sparkly eyes, big rounded beak, giving a thumbs-up with a wing, waving with the other wing, big friendly smile, sitting beside the grid. Bottom: a colorful rounded pill-shaped banner with bold white text outlined in orange reading Sudoku without Numbers. Bright, cheerful, polished 3D mobile game art style, high detail, soft shadows, vibrant colors.

Background swap (an edit, not a fresh generation — kept the same duck, only changed what's behind it)

Keep the cute 3D fluffy baby duck exactly the same, same pose, same face, same lighting. Replace only the background: a colorful sudoku-style puzzle grid board made of rounded square tiles in soft pastel colors (blue, yellow, pink, teal, purple, green), some tiles have a white X mark, seen at a slight angle, warm soft glow behind it, a few small sparkle stars floating around. Bright cheerful 3D mobile game art style.

Duckdoku: building a game in public

A puzzle game where you place one duck in every color, row and column, and ducks can't touch. I am building it from a single idea to a polished game, and I am writing down every step.


Day 1: From a chat to a plan

The idea

I love the cat puzzle game Meowdoku by Oakever Games. I wanted to know: can I build my own version, with my own theme and my own art? I asked ChatGPT.

The answer was: copy the mechanics (the rules), not the assets (art, sounds, levels). So I chose ducks instead of cats, and the name Duckdoku.

I kept four ChatGPT chats, in order. They are my design notes:

  1. Clone game mechanics. Rules, puzzle generator, screens, ads, coins, streaks.
  2. Player Income per Minute (IPM). A way to set every price and reward from "how many minutes of play is this worth?"
  3. Hints and the name. Three kinds of hints. Names like Capydoku, Foxdoku... I chose Duckdoku.
  4. The duck helper. A duck button that flies onto the board and places one correct duck.

The rules of Duckdoku

My reference screenshots

I took 23 screenshots of Meowdoku: the splash, the tutorial, the grid, the hint bar, the profile, the daily streak and the "Bravo" win screen. They are my style guide. I replace every cat with a duck.

One thing I checked before building: the shared chat and my screenshots did not match on the animal (chat: ducks, screenshots: cats). That is expected. The screenshots are what I copy, the chat is what I build. I also noticed that the chat says the cat is "2D with 3D-style parts", while I see it as a 3D cat. So I made the duck a 3D-looking picture inside a 2D game.

The 3D duck idea

In the reference, the cat looks to the top-left or top-right, and sometimes winks at you. It also winks when you place it on the grid. My game is 2D, but my duck is a 3D render. To get this feeling, I swap between rendered poses:

straight -> look top-left / top-right -> back -> (sometimes) wink


Day 1: Making the art (and what it cost)

Price check

I saved a screenshot of the OpenAI price table (gptprice.png). For GPT Image 2, medium quality:

SizePrice
1024 x 1024$0.053
1024 x 1536$0.041
1536 x 1024$0.041

I wanted 1080p. That is 1920 x 1080. The tool needs sizes that divide by 16, and 1080 does not, so I used 1920 x 1088. That has about 33% more pixels than 1536 x 1024, so I guessed about $0.055 per sheet.

Sprite sheets, not single images

Making 58 separate images would cost far more. So I asked for 7 sprite sheets, one image each, and cut them into pieces myself with a small Python script.

#SheetContents
1Duck faces8 poses: straight, look top-left, look top-right, wink left, wink right, happy, sad, sleepy
2Dance and win6 dance poses with party hat and glow sticks
3Duck actionswave, thumbs up, flying helper, detective, golden duck, thinking
4UI kitbuttons, panels, hearts, coins, X marks, bulb, stars, hand, check
5Streak and rewardsfeather-nest streak icon (on / off), gift box, day markers, treasure chest
6Avatars8 duck profile pictures
7Logo and splashDUCKDOKU logo and the splash duck

I made sheet 1 first and checked it. It looked right, so I used it as the reference picture for the other sheets. That is how the duck stays the same duck in every sheet.

One trick: I asked for a flat magenta background. Then my script turns magenta into see-through pixels.

Cost

(sprite sheets: see Assets/Art/Sheets, cut sprites: Assets/Resources/Sprites)

What was not perfect


Day 1: The puzzle engine

I built the brain of the game before any screens. Three parts:

  1. Generator. It places ducks so no two touch, grows colored areas around them, then checks the puzzle has exactly one answer. If not, it tries again. The same level number always gives the same puzzle.
  2. Solver. Counts solutions, up to 2. This is how I know a puzzle is fair.
  3. Board. Holds the state: crosses, ducks, hearts, score, undo, hints, helper.

Hints

The hint bulb finds a real deduction and says it in words, like "This color has only one place left!" Then it glows the color and shows a hand on the cell.

Money (from my IPM chat)

Reward = expected solve minutes x income per minute.

4x4 = 100 coins/min, and it grows with board size. A hint or a helper duck costs 100 coins once free ones run out. You get 3 free helper ducks per day.


Day 2: Sound (and a scare)

I bought the Ultimate Casual Game SFX and Music Pack on the Unity Asset Store. I told Unity to import it, and that was a mistake: the pack is 5.6 GB and Unity started copying all of it into my project. My disk was filling up, and Unity froze for many minutes. I closed Unity, moved the project to a bigger drive, and reopened it.

Lesson: look at the size of a package before you import it. Then I opened the package file myself and picked only 13 sounds (about 14 MB). They are in Assets/Resources/Audio:

I picked 13 sounds from the pack to cover the game's actions and screens: placing a duck, crossing out a cell, a mistake, winning, a hint, the helper duck, buttons, the streak page, and background music.

I cannot hear the sounds while I build, so I chose the quack by its name and length. I need to listen and swap it if it sounds like a car horn, not a duck. To change a sound, I only replace the file with the same name.


Day 2: Building the game in Unity

How it is built

The whole UI is built from code when the game starts. One empty object in the scene, Duckdoku, holds a script called GameApp. It makes the canvas, the menu, the game screen and the popups. This keeps everything easy to change, and the Hierarchy is still fully visible while playing.

Screens I made (all copied from the reference, with ducks)

  1. Splash. The logo and the duck pop in.
  2. Menu. Profile picture, coins, settings, streak, logo, Play, Daily Challenge.
  3. Game screen. Level, score, 3 hearts, a row of duck icons (one per color), the three rules, a coach message, the board, and three buttons: Undo, Helper duck, Hint.
  4. Bravo screen. A dancing duck with glow sticks, confetti, and the coin reward.
  5. Lose screen. A sad duck. Try again, or continue for 200 coins.
  6. Streak screen. The feather nest, current and best streak, and the 7-day row with a gift at the end.
  7. Profile with 8 duck avatars, and Settings with a Sound switch.

The duck that winks

The board duck is a picture, but it acts alive:

Test results

I tested the rules by playing through with code, not just by looking:

SizePuzzles with exactly one answerSpeed
4x4 to 7x725 of 25under 0.1 second
8x825 of 250.14 s average, worst 0.6 s
9x9only 7 of 25about 1 second

So I stopped the game at 8x8. A smarter region builder is on my to-do list for 9x9.

Bugs I found and fixed today


Screenshots

The game only

splash Splashmenu Menu
level 1 Level 1, the first puzzleplaced Two ducks placed. They wink. One heart lost, one cell crossed out
hint The hint and the pointing hand7x7 Level 20, a 7x7 board
win Bravostreak Streak
lose Out of heartsprofile Profile
settings Settings

Unity + gameplay together

Unity and gameplay

Unity UI (Hierarchy and Scene view)

Unity UI

Sprite sheets are in Docs/Sprite_Sheets.


What is next


Day 3: Feedback round. Twelve things to fix and add

After playing the first version, I wrote down 12 problems and wishes. Here is what I did about each one.

1. The "I cannot place a duck" bug (the most important one)

What was wrong: I trusted Unity's own "click count" to know if I double-tapped. The input system only counts two clicks if they are very fast (about 0.3 seconds), so on a real mouse or finger the game almost never saw a double-tap. The duck could not be placed.

The fix: I now measure the double-tap myself. Two taps on the same cell within 0.45 seconds place a duck. The first tap's cross is taken back automatically. This does not depend on the input system any more.

2. Buttons like the reference (image 1)

All text buttons are now flat pills with round ends, wide and short: orange for the main action, grey when locked, white for the second choice, green for extras. Level 1 and a locked Daily Challenge (opens after 5 levels) copy the reference idea. I kept the round icon buttons round.

3. Copy the style, not every pixel

I redesigned the pages in my own way:

4. Tutorial (first run only)

A guided 4x4 board. A hand icon shows what to do and the rest of the board is dimmed:

  1. Double-tap a cell: the hand taps twice. The duck pops in and winks.
  2. Single tap a cell in the same column: the hand taps once. A cross spins in.
  3. Cross out another cell in the row.
  4. Double-tap the next duck. "Only one duck per color."
  5. Tap the hint bulb.
  6. Finish the board. Confetti, "Excellent! You've mastered the rules!" and a Start Game button.

After the tutorial, it never shows again (I can replay it from Settings).

5. Was the economy from the GPT chat built?

Partly. Here is the honest list.

From the chatDone?
Reward = play minutes x income per minute (100 coins per minute at 4x4, grows with board size)Yes
Hint costs 100 coins after the free ones, helper duck: 3 free a day, then 100 coinsYes
Continue after losing = 200 coins (2 minutes)Yes
Daily puzzle bonus (+200)Yes
Stars: +5% / +10% / +15% bonus (3 stars = no mistakes)Yes, new today
Streak rewards: day 7 = 1,500, day 14 = 3,000, day 30 = 7,500 coinsYes, new today
Cosmetic prices: avatars cost 1,000 to 6,000 coins (10 to 60 minutes of play)Yes, new today
Income growing by world (100, 110, 120, 135 ...)Only a simple version (grows with board size)
XP and levelsNo
Rewarded adsNo (needs an ads SDK)

6. Effects from asset packs

The pack was only 0.9 MB, so I imported it after checking its size (lesson from the sound pack). I use a mix of effects from the Hyper Casual FX pack and the Cartoon FX Remaster pack throughout the game.

7. A test page for every sound and effect

Settings > Test SFX & VFX. A hidden developer page with one button for every game sound and every visual effect, so I could preview each one on its own without playing through the whole game.

8. New duck animations (sprite sheets)

I generated two more sheets with the same duck: a 6-frame victory jump and a 6-frame crying animation. The Bravo page and the lose page play them.

9. New logo, icon, splash and featured image

10. DOTween everywhere

I used DOTween for the game's animations. I removed my old hand-made animation code.

Image cost (real numbers from the API log)

The API tells me how many tokens each image used. Output tokens cost $30 per million, and this matches your price table (1,325 tokens = $0.040, and the table says $0.041 for 1536x1024).

BatchImagesEstimated cost
First 7 sprite sheets7about $0.34
Logo, win sheet, lose sheet, icon, splash, featured6about $0.32
Total13about $0.66 (budget was $1)

Two calls failed and made no image: the first featured image (size too small) and one network error.

The price of the images I gave the model as reference is a guess ($8 per million), so the real total may be a little lower. I still need to compare with the OpenAI billing page.

Bugs I found while testing today

Not done yet


Day 4: More feedback. 17 changes

I played the game again and wrote down 17 things. Here is what changed.

The double-tap bug, again (the real cause)

Last time I measured the double-tap myself, but I was still listening for Unity's click event. A click is thrown away if the finger moves even a little between press and release. That is why it worked "sometimes". Now the game listens for the press itself, so nothing is thrown away, and the time window is 1 second (I had 0.45 seconds).

New: drag to cross many cells

Press a cell and drag over other cells: they all get a cross. If you start on a cell that already has a cross, dragging takes the crosses away.

Tutorial v2 (the full lesson)

StepWhat the player does
1Double-tap to place a duck
2Cross out every cell the duck blocks: its row, column, color and touching cells (8 cells on the tutorial board). Tap, or drag. The coach shows a counter (3/8). The hand shows the drag.
3Tap the helper duck (it places a duck)
4Cross out the cells the new duck blocks
5Tap Undo to take back the last move
6Cross that cell out again
7Tap the hint bulb
8Place the last ducks

At the end there are two buttons: Start Game and Replay tutorial.

The hand had a bug where it could be missing: I found that DOTween was re-using finished tweens, so my saved hand animation could be killed by something else. I turned re-use off, and I added a safety: if the hand is not on screen for 1.2 seconds, it comes back.

Screens

Sound

Things I could not check


Day 5: A real level plan, and more polish

New sounds you picked

I picked more specific sounds from the pack for a handful of moments, and set the home screen and the game to share one background music loop, so it never restarts between screens.

Screens

The puzzle plan (from the design chat)

The design chat said the game must teach the rules through play, and that every puzzle needs exactly one answer and a difficulty a person can reach without guessing. I built that in three parts.

1. A level table (LevelDesign)

LevelsBoardDucks already placedWhat it teaches
1-34x42rows
4-64x41-2columns
7-104x41-2colors
11-154x41no touching
16-204x40-1the diagonal
21-305x51-2using all rules
31-455x50-1longer chains
46-606x61more colors
61-806x60-1multi-step
81-1007x71irregular colors
101-1257x70-1complex
126-1508x80-1dense
151+8x80long chains

The starting ducks have a small lock and cannot be moved. The rule the level teaches is lit up with an orange border on the rule card, and the coach says it in one line.

2. A "human solver" (HumanSolver). It solves each puzzle like a person, and counts how hard the deductions were:

  1. only one place is left in a row, column or color
  2. a color fits in one row or column only
  3. the same with two colors
  4. "what if I put a duck here?" ends in a dead end, or the same with three colors

If none of these help, the puzzle needs guessing, and it is thrown away.

3. A generator that keeps only puzzles that fit the level. Same level, same puzzle, every time. Each puzzle shows a word under the title: Very easy, Easy, Medium, Hard, Expert.

Update (Day 10): this plan changed later. From level 21 a level can have several valid answers, and the game now shows how many. The table and the "exactly one solution" line below describe the first version. See Day 10 at the end.

Test result, all 200 levels:

My first version failed on the big boards (levels 101 and up): puzzles with one answer were too rare on 8x8. The fix: when a puzzle has several answers, the generator nudges single cells to another color until only one answer is left.

Economy numbers changed to match the plan

Not built yet (also in the design chat)

The shop with outfits (1,000 to 30,000 coins), Remove Ads, the three hint levels (highlight, explain, place) and the ad schedule. They need a shop screen and an ads SDK. I did not build them because you asked for the puzzle redesign.


Day 6: Fixes, a restart button, and the shop

Design change: no "one rule per 3 levels"

I first built the level table so that levels 1-20 each taught one rule (rows, then columns...). You said no: every level uses all the rules, and the tutorial (level zero) teaches them. I removed the lesson text and the orange rule highlight. The table keeps only the board size, the number of starting ducks, and the difficulty.


Day 7: Breathing room, a better shop button, and the first Android build

Spacing (checked on every screen)

Rule I now follow: at least 40 units of empty space around anything inside a card, and about 100 units between the bottom button row and the edge of the phone. The old game screen had its bottom captions only 13 units from the edge, which a phone's gesture bar would cover.

Coins while playing

The game screen (and the daily challenge, which uses the same screen) now has a coin chip next to hearts and score. When you pay for something, the number counts down and a red -150 floats away, so it is clear where the coins went.

Shop button

It is now a big orange button with the treasure chest sticking out on the left, and a red ! when there is something you can afford.

Test page fixes

Android

Package name com.sid.duckdoku, ARM64, portrait, IL2CPP, minimum Android 8 (API 26). The 5 GB sound packs are not in the build (only the small Resources folder is), and the Sound Lab is editor-only.


Day 8: Bigger back buttons, a full-screen "life lost", ads, purchases and the Play Store

Look and feel

Money side (nothing was live yet, all tested with test ads and fake purchases)

Play Store steps


Day 9: Would "low" quality have been enough? (an image cost test)

All the art on Day 1 was made at medium quality. Today I asked one question: what if I had used low? So I made the same 7 sprite sheets again at low quality, and compared price, time and look.

The exact setup

Four sprite sheets side by side: medium quality on the left, low quality on the right

Medium quality on the left, low quality on the right (avatars, UI kit, dance poses, streak and rewards).

All 58 sprites cut from the low quality sheets

All 58 sprites cut from the low quality sheets.

Tokens, time and price (real numbers from the API log)

Tokens are the pieces OpenAI counts and charges for. Output tokens cost $30 per million (a real price). The price of input tokens is my guess ($5 per million for text, $8 per million for a reference picture), so the "estimated total" columns are only estimates.

SheetOutput tokens, mediumOutput tokens, lowTime, mediumTime, lowEstimated total, mediumEstimated total, low
1 Duck faces1,32514827 s17 s$0.041$0.006
2 Dance and win1,32514837 s27 s$0.054$0.018
3 Duck actions1,32514837 s27 s$0.053$0.018
4 UI kit1,32514831 s19 s$0.042$0.006
5 Streak and rewards1,32514828 s15 s$0.041$0.006
6 Avatars1,32514833 s27 s$0.053$0.018
7 Logo and splash1,32514834 s26 s$0.053$0.018
All 7 sheets$0.34$0.09

What I learned:

  1. The output price is fixed by size and quality, not by the prompt. Every 1920x1088 sheet used exactly 1,325 tokens at medium and exactly 148 at low. So the price of an image can be worked out before you make it.
  2. Low is about 9 times cheaper on output ($0.040 against $0.004 per sheet).
  3. But only about 3.7 times cheaper in total, because a reference picture costs about 1,508 input tokens at any quality.
  4. Low is also faster (15 to 27 seconds, against 27 to 37).

Was the look good enough?

Mostly yes. Shapes, poses, faces and UI pieces are the same and sharp. What changed:

My advice: use low for tests and first drafts. Use medium for the final art, and when a new picture must match ducks you already have.

What I did not test: I made each sheet once, so colors may change from run to run. The yellow color already shows in the low faces sheet, and that sheet was the reference for four other sheets, so part of the color change may have been passed along. I did not test low sheets with the medium faces sheet as the reference, and I did not test high quality. My estimate for this whole test is about $0.09; I still need to check it on the OpenAI billing page.

A rate limit to remember: the image API allows only 5 reference pictures per minute. On Day 1 one call failed with error 429 because of this. On Day 9 I made the 3 sheets without a reference first, then the 4 sheets with a reference, and there was no error.

Day 10: Several answers, a full-answer button, and the App Store

After the first players, I changed how levels work. These are the new rules, in plain words.

I also tested this the same way as before: a small program solved levels and counted the answers (for the rule above, with the starting ducks), and the game was played in the Unity Editor to look at every screen.

Duckdoku on iPhone and iPad

The iOS version is now on the App Store. Apple asked for the App Tracking question to come before any ad code, and I added a screenshot set in the sizes Apple needs (iPhone 6.3 inch and iPad 13 inch). A new App Store version needs a new build number every time, even if you change only the screenshots.