This game kinda rules...

It was supposed to come out around the same time as the original Animal Crossing, but was canceled and so never made it outside of Japan. There's no fan translation mod, but a script translation is floating around.

Giftpia was produced by members of the same team who made Moon: Remix RPG Adventure, and its influence is obvious. You have a set amount of time in a day to run around and perform tasks, and you die if that time elapses. As the game progresses, you can stay up later and later so you can explore more far-flung areas of the map. And just like in Moon, the soundtrack is almost all songs from existing real-world bands (but you're not able to choose your own soundtrack like you can in Moon). The songs, frankly, slap -- some of my favorites are a great folky Japanese tune and a tango.

It's much more linear than Moon, but it's got a distinct Animal Crossing-like charm that I really enjoyed. Moon has more of an 'esoteric fantasy' vibe that was a bit harder to get into, plus some of the puzzles in that game are downright stupid. I only needed to consult a walkthrough once for Giftpia.

(yes I played it on my phone the first time)

"Shut up! You stupid trash robot! You can only talk in katakana so don't act all great!"

"I thought if I ate a lot of mushrooms I'd be able to die... but I became a chicken..."

The game honestly looks great. The cartoony cel-shaded style has aged really well, just like Wind Waker's did.

During the game, you get a camera that you can use to take pictures of all the characters around town. Eventually, you unlock a gacha vending machine that randomly dispenses figurines made from these photos (so you can get duplicates, and it will get harder and harder to get new ones). I eventually did get all the figurines. You do not get a reward for doing this.

This game also has a puzzle in it that I struggled with so much that I had to write a Python program to solve it. In this screenshot you can see the puzzle after it's been solved. But basically there are a bunch of small islands that you run around, and whenever you step on one the height of adjacent islands changes. You need to get from one side to the other, and it has to be at the right height.

I'm not sure if you can skip this puzzle, in fact I don't believe any of the puzzles in Giftpia are supposed to be skippable.

This idiot doesn't know how much I labored to get him this huge fish... (also once you unlock fishing here it's basically a cheat code to infinite money, everything you can get in here sells for a LOT)

    
#        8
#       ||
#      1 2 3
# 7 =  4 5 6
#       ||
#        0
# adjacencies dict never needs to change
adjacencies = { 0 : (5,),
                1 : (2,4),
                2 : (1,3,5,8),
                3 : (2,6),
                4 : (1,5,7),
                5 : (0,2,4,6),
                6 : (3,5),
                7 : (4,),
                8 : (2,) }
# states dict will be updated as pockle moves around
# we'll just make copies of this initial one
initialStates = { 0 : 1,
                  1 : 1,
                  2 : 3,
                  3 : 1,
                  4 : 3,
                  5 : 1,
                  6 : 3,
                  7 : 2,
                  8 : 1 }

# used to log the different paths traversed by the algorithm
# this way if we find a winning path we can return it to the user
# i was originally going to make this have a children field
# which linked to each child but i don't actually need that.
# i just need to be able to retrace backwards from the winning node.
class Node:
  def __init__(self, pos, parent):
    self.pos = pos
    self.parent = parent

def getNextHeight(height):
  ret = height - 1
  if ret == 0:
    ret = 3
  return ret

winningPath = None
def evalPath(pos, states, node):
  # print "eval pos {}".format(pos)
  # make a copy since we don't want to modify the original
  states = dict(states)
  if pos in (1, 3, 5):
    states[1] = getNextHeight(states[1])
    states[3] = getNextHeight(states[3])
    states[5] = getNextHeight(states[5])
  elif pos in (2, 4, 6):
    states[1] = getNextHeight(states[1])
    states[3] = getNextHeight(states[3])
    states[5] = getNextHeight(states[5])
    states[pos] = getNextHeight(states[pos])
  # print "state is now: {}".format(states)

  if (pos == 2) and (states[2] == states[8]):
    winningPath = node
    while node is not None:
      print node.pos
      node = node.parent
    raise Exception("we have a winner!")

  for adj in adjacencies[pos]:
    if states[adj] == states[pos]:
      evalPath(adj, states, Node(adj, node))

# start him off at 0
# (could also start him at 5 with different starting heights)
try:
  evalPath(0, initialStates, Node(0, None))
except:
  pass
    
    

2
1
4
5
6
5
4
7
4
5
0
5
2
5
0

Genuinely not sure how anybody ever figured this puzzle out, I mean just look at all the freakin' steps in the solution! Maybe there's a simpler one and my program just didn't find it.