orchard

Cart File | Forum Post |

	More cartridges by shensat

More Cartridges [View All]

 

orchard

by shensat

Cart #orchard-4 | 2022-06-19 | Code ▽ | Embed ▽ | License: CC4-BY-NC-SA

21

Controls

Move card: ⬆️ ⬅️ ⬇️ ➡️ keys
Rotate card: tap "Z" key
Place card: hold "Z" key + tap ⬇️ key
Help screen: hold "X" key

Rules

The aim of the game is to grow trees in your orchard by placing cards. The more trees you have, and the older the trees are, the more points you will score. 🌳

You can only place cards when at least one of its fruit types (apple/lemon/blueberry) overlaps an existing fruit type in the orchard. Once a card is placed, any matching fruit types underneath the card will grow.

Behind the scenes

This is my first ever (full) pico8 game. I'm a web developer by trade and I had a lot of fun transferring some code principles from web developemnt to game development. For example, Don't Repeat Yourself (Dry) and the single responsibility principle.

I have tried to remake video games in pico8 before, but I always had trouble replicating games that gave the player a lot of freedom in terms of movement/behaviour - my code would quickly balloon in size and become a mess! 😥

By choosing to remake Orchard, a physical card game, I was essentially placing constraints upon the system: player movement is limited (ie movement is card- or tile-based) and a player can only do one of two things at any one time (move or place a card). With these constraints in place, the game was (relatively 😅) easier to make.

One thing I haven't been able to carry over from web development is the concept of automated testing. I don't understand how people are able to create complex games without automated tests - it honestly blows my mind! 🤯 I'd love to create a testing framework for pico8 one day ❤️

Credits

Code, sprites, sfx and music by me! 😄
This game is a pico8 remake of an existing card game of the same name. You can check out and buy its sequel here

Also, a massive shoutout to the LazyDevs channel for teaching me how to upload a game to lexaloffle 🙏🏾

Thank you for posting the game here! :D

That was quite satisfying. I may have been lucky with two cards that perfectly overlapped an entire existing 2×3 area. Is the scoring linear for the amount of growth a plant has had?

Regarding testing, you could run all-up tests using the record and replay system of a Tool-Assisted Speedrun. However, I'm not sure how to unit test individual functions or objects.

Thanks for the feedback peeps :)

To your question Cowirrie: the scoring is indeed linear. I could make it non-linear (ie more points for older trees) to encourage players to keep their orchards small but maturer (ie fewer trees but each tree is older).

That article on TAS was amazing, thank for posting it! I'd not read much about speedruns before so that was cool, but using the same tool as a kind of "frame-by-frame-pico8-manipulator" for testing makes so much sense to me. It would be analogous to a feature test in web development, whereby the automated tests simulate button clicks by the user.

I dig this quite a bit. It's a nice little zen game that feels gratifying. Having some sort of stat bar or something might be helpful. I kept placing trees and was having fun and then all of sudden it was over and I'm not sure why. Did I run out of time? Do I only have so many cards to play? Does it only last X number of days? Just something to help me think/plan about my moves and scoring.

I think there's a ton here you could build on. I think Orchard II would be worth it! :)

Very nice release and I'll certainly be playing it on my handheld when I need a little breather.

Thanks so much for the feedback! I was definitely going for the zen vibes :)
That's a really good point re: a progress bar - I had originally put the number-of-cards-left-to-play in the top left corner of the screen. But I removed it because I opted to go for a super clean/minimal UI. I could certainly add it in for Orchard II 🙌

A few people on Reddit have said they are going to play it on handheld too. Do you recommend any handhelds for pico8 games? So far I've only heard of rg351m

Nice game! I was very excited when I saw it for Pico-8, since I have played the Kickstarter print-and-play card game (https://boardgamegeek.com/boardgame/245487/orchard-9-card-solitaire-game), by Mark Tuck, a lot .

Unfortunately doesn't this Pico8-game implementation follow the original Kickstarter game rules (https://boardgamegeek.com/filepage/159520/orchard-rules-v1), which resulting in that it is very easy to get very high scores.

Here is a list the issues that I have found so far:

• This game only have one card to play each round, in the original you have two cards in your hand to select one from to play.

• This game sources 3-6-9 for the overlaps, while the original scores 1-3-6-10.

• This game repeats the cards a lot during a game, so it is much easier to get high point, since all fruit for those cards then can overlap. While in the original, all cards are unique.

• This game sometime shows card that are not among the original cards (https://boardgamegeek.com/filepage/166414/orchard-cards-numbered-v-1) . I have for example seem cards with 3 apples, which does not exist in the original deck. It always have two of each fruit.

Maybe you can address these, or some of these issues in the next revision.

By the way, thanks for the reference to the sequel, GROVE. I did not know about that one.
I will be printing the print-and-play edition tonight, and see how that game is.

Keep up the good work, I will be looking for the next revision.

	[16x16]

Great puzzle! =)

Really satisfying game! I think it is a little too easy; I've played 3 games and have gotten 50+ points each time. But it is nice and relaxing and the tree growing animation is very satisfying.

I agree that non-linear scoring would work better than linear, I think. Also it is easy to get lost on the grid. I was panning around and lost my orchard! But it's really fun and zen. :)

The game is very good and just perfect in terms of length and challenge. I just found the ranking too easy. I was super lucky in the second round with a full, successful card and significantly better than the first round, but that wasn't reflected in the rating. Maybe it's because of the changed scoring mechanics that blixten already addressed in the comments.

Thanks again for the feedback peeps, I really appreciate it 🙏🏾

A main theme that seems to be forming from the feedback is that the game is too easy - I can rectify this by changing the cards that spawn to have fruit that are "less likely" to overlap with each other.

Blixten, thank you for the detailed feedback with differences between my game vs the physical game. I had left out the features you mentioned because of the problem I have with scope and time - often I find that my projects grow too big in terms of code and I never finish them 😅 That said, I can certainly make the changes you pointed out regarding points and the types of cards that spawn. I'm also glad you now know about the sequel physical card game (it's something I disocvered only recently too!)

This is great. Shame it's too short. I could definitely see this a mobile time killer

An indeed relaxing little game, I agree the main issue is it's basically 'impossible' to score lower than 50 unless you're playing on purpose randomly placing until outer fruits match. I played like ten rounds all pear-fect.
So the current difficulty could be the starting one and then make it more challenging each level, maybe avoiding a timer (to lose its Zen vibe 😉)

And thanks for the extra feedback - I'm so happy lots of people have played the game but delighted you've taken the time to give feedback ❤️
I clearly need to make the cards less "match-able" to make the game more difficiult.
@Heracleum levels differentiated by difficulty is a great idea! Once I've figured out how to make cards less/more "match-able", levels would totally be do-able

I've now taken some time to look at your ( @shensat) code, and I fixed two of my previously reported issues.

• issue 3: regarding the repeated cards. In your code

  • card_one is the same as card_six
  • card_two is the same as card_seven
  • card_three is the same as card_eight
• issue 4: wrong card that is not among the cards in the original deck.
  • card_nine has three (!?) apples.

So I replaced your card table and shuffle loop:

card_one = { copy_table(lemon), copy_table(berry), copy_table(apple), copy_table(apple), copy_table(lemon), copy_table(berry) }
card_two = { copy_table(lemon), copy_table(lemon), copy_table(berry), copy_table(apple), copy_table(apple), copy_table(berry) }
card_three = { copy_table(lemon), copy_table(apple), copy_table(berry), copy_table(lemon), copy_table(apple), copy_table(berry) }
card_four = { copy_table(berry), copy_table(berry), copy_table(apple), copy_table(lemon), copy_table(lemon), copy_table(apple) }
card_five = { copy_table(berry), copy_table(apple), copy_table(lemon), copy_table(lemon), copy_table(apple), copy_table(berry) }
card_six = { copy_table(lemon), copy_table(berry), copy_table(apple), copy_table(apple), copy_table(lemon), copy_table(berry) }
card_seven = { copy_table(lemon), copy_table(lemon), copy_table(berry), copy_table(apple), copy_table(apple), copy_table(berry) }
card_eight = { copy_table(lemon), copy_table(apple), copy_table(berry), copy_table(lemon), copy_table(apple), copy_table(berry) }
card_nine = { copy_table(apple), copy_table(apple), copy_table(berry), copy_table(lemon), copy_table(lemon), copy_table(apple) }

starting_cards = { card_one, card_two, card_three, card_four, card_five, card_six, card_seven, card_eight, card_nine }

shuffled_cards = {}
no_of_starting_cards = #starting_cards

for c=1,no_of_starting_cards do
  local i = flr(rnd(#starting_cards)) + 1
  local card = starting_cards[i]
  del(starting_cards,card)
  add(shuffled_cards,card)
end

with the double sides cards from the original deck:

starting_cards = {{ -- Nine two-sided cards
    {copy_table(berry), copy_table(apple), copy_table(apple), copy_table(berry), copy_table(lemon), copy_table(lemon)}, -- 1
    {copy_table(apple), copy_table(berry), copy_table(apple), copy_table(berry), copy_table(lemon), copy_table(lemon)}  -- 2
  }, {
    {copy_table(berry), copy_table(apple), copy_table(lemon), copy_table(lemon), copy_table(apple), copy_table(berry)}, -- 3
    {copy_table(apple), copy_table(berry), copy_table(lemon), copy_table(lemon), copy_table(apple), copy_table(berry)}  -- 4
  }, {
    {copy_table(apple), copy_table(lemon), copy_table(berry), copy_table(berry), copy_table(lemon), copy_table(apple)}, -- 5
    {copy_table(lemon), copy_table(apple), copy_table(berry), copy_table(berry), copy_table(lemon), copy_table(apple)}  -- 6
  }, {
    {copy_table(lemon), copy_table(apple), copy_table(lemon), copy_table(berry), copy_table(apple), copy_table(berry)}, -- 7
    {copy_table(lemon), copy_table(apple), copy_table(berry), copy_table(lemon), copy_table(apple), copy_table(berry)}  -- 8
  }, {
    {copy_table(berry), copy_table(lemon), copy_table(berry), copy_table(apple), copy_table(lemon), copy_table(apple)}, -- 9
    {copy_table(berry), copy_table(lemon), copy_table(apple), copy_table(berry), copy_table(lemon), copy_table(apple)}  -- 10
  }, {
    {copy_table(berry), copy_table(berry), copy_table(apple), copy_table(lemon), copy_table(lemon), copy_table(apple)}, -- 11
    {copy_table(berry), copy_table(berry), copy_table(apple), copy_table(lemon), copy_table(apple), copy_table(lemon)}  -- 12
  }, {
    {copy_table(apple), copy_table(berry), copy_table(apple), copy_table(lemon), copy_table(berry), copy_table(lemon)}, -- 13
    {copy_table(apple), copy_table(berry), copy_table(lemon), copy_table(apple), copy_table(berry), copy_table(lemon)}  -- 14
  }, {
    {copy_table(lemon), copy_table(berry), copy_table(apple), copy_table(apple), copy_table(berry), copy_table(lemon)}, -- 15
    {copy_table(berry), copy_table(lemon), copy_table(apple), copy_table(apple), copy_table(berry), copy_table(lemon)}  -- 16
  }, {
    {copy_table(apple), copy_table(apple), copy_table(lemon), copy_table(berry), copy_table(berry), copy_table(lemon)}, -- 17
    {copy_table(apple), copy_table(apple), copy_table(lemon), copy_table(berry), copy_table(lemon), copy_table(berry)}  -- 18
  }
}

shuffled_cards = {}
no_of_starting_cards = #starting_cards

for c=1,no_of_starting_cards do
  local card = rnd(starting_cards) -- Get a random card
  local side = rnd(card)           -- Select random side of that card
  del(starting_cards, card)
  add(shuffled_cards, side)
end

So now it's a little "easier" to NOT get a "pear-fect" score ;-)

@blixten thank you so much for the amended code! 💛
I've changed it a teensy weensy bit and put it into the game.
Hopefully players will find the game more challenging now 💪
Btw: did you play Grove? If so, what did you think? I've yet to buy/play it