Idea: Little Computer People For Pokitto


#1

Hmmm, instead of sims clone, could a simple Little Computer People work on pokitto?
There was a guy making a rebuild for pocket chip but he quit when the company went belly up.

Seriously I love this game and it ran on a Sinclair zx

I’d be happy to help with grapiics if I could.

As for gta, a top down game in retro graphics would be neat, and perhaps a map making app for pokitto to make your own maps and store them on the as card.


Pokitto needs
#2

Just an idea, pokitto’s mansion,
Pokitto goes on a trip from Finland and finds a house and its haunted pokitto gets to live there if it can catch all 100 (just a starting idea) ghosts
A button shines light b button catches ghost and dumps them in the storage, each ghost is unique and worth points but all are hidden in places in the mansion and you have to find most via simple puzzles.

Basically like Luigi’s mansion but starring 8 bit pokitto

You charge the light by storing ghosts, you use the light to find them / see them so you can trap them.

Please note I’ve never played Luigi’s mansion I just know the basic idea.


#3

Also a tamagotchi / digimon game.


#4

Little Computer People look so very nice, we need Little Pokitto People :slight_smile:


#5

The main “commands” were all 1 button, and if we reserve c for saving and exiting and use the + key for commands we have easily 12 commands.

The originals were
Food
Water
Alarm
Dog food

And
Call on phone
Pet
Give a record
Give a book

This leaves 4 buttons

This is the manual for the game
http://www.lemonamiga.com/games/docs.php?id=1008

Only problem I can see is the memory, c64 had well 64k And pokitto has 36k however I believe it can be delt with this is 36 years later.


#6

That’s relative to the power of the CPU though.

The Commodore64 had a modified MOS 6502, (roughly the same chip as a SNES),
which was an 8-bit CPU with only 6 registers,
so it would take several instructions on a MOS to achieve what the Pokitto’s Cortex M0+ can do in just one instruction.

Plus, it should be possible to offload some data onto the SD card.


#7

Lol want to help? You know I am illiterate and all when it comes to code.

This could be the pokitto killer app. :blush:


#8

ok, LCP had a unique person for every copy of the disc. now with a digital download it is just not feasible to give each download a unique serial number so Id suggest that be covered by your username and date you start the game, both of which the game asks for, this can decide the LCP stats, LCP has only got one gender and color, but I would prefer to see male and female, and either a colorless character like lego yellow, or at least white and black in both genders,

the stats they need are
hunger
thirst
attention
socialisation

and the pet if it is implemented would need hunger and thirst as well

the stats could be a 1-10 scale, with 1 being minimal 10 being excessive,
1 hunger is that anorexic woman bikini model, 5 average 8 teenage boy 10 roman vomitorium patron

these would just be to control little bits of the personality, and how much they use resources and need attention , and interests, since there is potentially 4 more actions with pokitto, perhaps music, books video game could be interests,
saving a button to tell the pokitto to scroll through the rooms of the house if it needs to be done that way since the screen is so small,

the house has a living room with the front door and a chair and a phone,
the kitchen where the food and water is stored,
upstairs is the bathroom door and bedroom
and the attic is where they keep their books and records,

character variables
gender 2
hair 4 (two each gender short and long female and male)
race 2 initially
shirts 4 two male two female long sleeve and short sleeve
pants 2 for male (shorts or trousers)
skirts 2 for female mini and knee length
shoes just one type with different colors

the colors for shirts and bottoms can be based on the color pallet for the game,
and if implemented pet, either a cat or dog,

the houses would all be the same so no work there, beyond just making them the hard part would be the animations, walking talking on the phone, being petted, reading, etc.

The house would need to save to sd, as well. Though the original didn’t so much seem to save as reload the character and acknowledge that time passed, though I’m sure pokitto could save and have resources deplete during the time away.

Game flow is log in, which generates the lcp, and then you wait a bit and the lcp will come check out the house then leave and bring their bags, to move in.
The first day or so they will lounge about doing stuff as you observe and care for them then perhaps they find a job and leave for a few hours each day. Eventually they will ask for a pet and you can give them one not sure if you chose or they decide either could be ok. And perhaps their job could be how they get food and luxuries? In the original these were limitless.


#9

I always focused strictly on house building in Sims, I’ve never really been into the people :neutral_face: So a building aspect would be important for me. Or at least a big level of house customization.


#10

Could be done


#11

If you had a server that could run scripts it would be relatively feasible - you could just use the person’s IP address.

That would mean some people wouldn’t always get the same unique character, but they’d probably end up with roughly the same batch of 256.

I miss the days when Lego ‘minifigures’ were yellow.
(I remember when they first switched to natural skin tones.)

If multiple colours won’t fit, yellow gets my vote.

Technically there is no black and white,
all humans are just different shades of brown :P
(Thanks Bill Nye.)

0-15 is better, that way you can fit it into 4 bits.

(In case you haven’t got to grips with bits yet: https://www.mathsisfun.com/binary-number-system.html)

Where I’m from most people call these a ‘lounge’ and a ‘loft:P

What if I told you those could all fit into a single byte?

This might not make much sense to you, but I’ll throw it up anyway:

You can do it the short but slightly less safe way:

enum class Characteristics : std::uint8_t
{
	Female = (0 << 0),
	Male = (1 << 0),
	
	ShortHair = (0 << 1),
	LongHair = (1 << 1),
	
	LightSkin = (0 << 2),
	DarkSkin = (1 << 2),
	
	ShortShirt = (0 << 3),
	LongShirt = (1 << 3),
	
	ShortTrouser = (0 << 4),
	LongTrouser = (1 << 4),
	ShortSkirt = ((1 << 5) | (0 << 4)),
	LongSkirt = ((1 << 5) | (1 << 4)),
	
	BlackShoe = (0 << 6),
	BrownShoe = (1 << 6),
};

constexpr Characteristics operator |(Characteristics left, Characteristics right)
{
	return static_cast<Characteristics>(static_cast<std::uint8_t>(left) | static_cast<std::uint8_t>(right));
}

Characteristics character =
	Characteristics::Male |
	Characteristics::LongHair |
	Characteristics::LightSkin |
	Characteristics::LongShirt |
	Characteristics::LongTrouser |
	Characteristics::BlackShoe;

Or the longer, safer way:

enum class Sex : std::uint8_t
{
	Female = 0, Male = 1,
};

enum class HairStyle : std::uint8_t
{
	Short = 0, Long = 1,
};

enum class SkinTone : std::uint8_t
{
	Light = 0, Dark = 1,
};

enum class ShirtStyle : std::uint8_t
{
	Short = 0, Long = 1,
};

enum class TrouserStyle : std::uint8_t
{
	Short = 0, Long = 1,
};

enum class SkirtStyle : std::uint8_t
{
	Short = 0, Long = 1,
};

enum class ShoeColour : std::uint8_t
{
	Black = 0, Brown = 1,
};

class CharacterDetails
{
private:
	constexpr std::uint8_t SexShift = 0;
	constexpr std::uint8_t HairShift = 1;
	constexpr std::uint8_t SkinShift = 2;
	constexpr std::uint8_t ShirtShift = 3;
	constexpr std::uint8_t TrouserShift = 4;
	constexpr std::uint8_t SkirtShift = 5;
	constexpr std::uint8_t ShoeShift = 6;
	
	constexpr std::uint8_t SexMask = 0x01;
	constexpr std::uint8_t HairMask = 0x01;
	constexpr std::uint8_t SkinMask = 0x01;
	constexpr std::uint8_t ShirtMask = 0x01;
	constexpr std::uint8_t TrouserMask = 0x01;
	constexpr std::uint8_t SkirtMask = 0x01;
	constexpr std::uint8_t ShoeMask = 0x01;

private:
	std::uint8_t value;
	
	constexpr std::uint8_t buildValue(Sex sex, HairStyle hairStyle, SkinTone skinTone, ShirtStyle shirtStyle, TrouserStyle trouserStyle, SkirtStyle skirtStyle, ShoeStyle shoeStyle)
	{
		return static_cast<std::uint8_t>
		(
			((static_cast<std::uint8_t>(sex) & SexMask) << SexShift) |
			((static_cast<std::uint8_t>(hairStyle) & HairMask) << HairShift) |
			((static_cast<std::uint8_t>(skinTone) & SkinMask) << SkinShift) |
			((static_cast<std::uint8_t>(shirtStyle) & ShirtMask) << ShirtShift) |
			((static_cast<std::uint8_t>(trouserStyle) & TrouserMask) << TrouserShift) |
			((static_cast<std::uint8_t>(skirtStyle) & SkirtMask) << SkirtShift) |
			((static_cast<std::uint8_t>(shoeStyle) & ShoeMask) << ShoeShift)			
		);
	}
	
public:
	explicit CharacterDetails(std::uint8_t value)
		: value(value)
	{
	}
	
	CharacterDetails(Sex sex, HairStyle hairStyle, SkinTone skinTone, ShirtStyle shirtStyle, TrouserStyle trouserStyle, SkirtStyle skirtStyle, ShoeStyle shoeStyle)
		: value(buildValue(sex, hairStyle, skinTone, shirtStyle, trouserStyle, skirtStyle, shoeStyle))
	{
	}
	
	constexpr Sex getSex(void) const
	{
		return static_cast<Sex>((this->value >> SexShift) & SexMask);
	}
	
	constexpr HairStyle getHairStyle(void) const
	{
		return static_cast<HairStyle>((this->value >> HairShift) & HairMask);
	}
	
	constexpr SkinTone getSkinTone(void) const
	{
		return static_cast<SkinTone>((this->value >> SkinShift) & SkinMask);
	}
	
	constexpr ShirtStyle getShirtStyle(void) const
	{
		return static_cast<ShirtStyle>((this->value >> ShirtShift) & ShirtMask);
	}
	
	constexpr TrouserStyle getTrouserStyle(void) const
	{
		return static_cast<TrouserStyle>((this->value >> TrouserShift) & TrouserMask);
	}
	
	constexpr SkirtStyle getSkirtStyle(void) const
	{
		return static_cast<SkirtStyle>((this->value >> SkirtShift) & SkirtMask);
	}
	
	constexpr ShoeStyle getShoeStyle(void) const
	{
		return static_cast<ShoeStyle>((this->value >> ShoeShift) & ShoeMask);
	}
};

Either way, there’s 128 permutations, so the biggest problem isn’t keeping character stats small, it’s providing the sprites for the characters.
You’d have to have a way of generating the sprites from pieces, otherwise you’d have to make 128 images.

Shoes and skin could be palette swapped, so that drops it to about 32 images.

However you can just paste hair and clothing on top of a base,
so that means you’d need:

  • 1 male base image
  • 1 female base image
  • 2 shoes (male & female)
  • 2 short tops (male & female)
  • 2 long top (male & female)
  • 2 short trousers (male & female)
  • 2 long trousers (male & female)
  • 2 short skirt (male & female)
  • 2 long skirt (male & female)

Which takes you to 16 images.
But you can cheat by merging the shoes onto the base image to drop that down to 14 images.
Then you can do a trick so that the male skirts actually refer to the images for the male trousers (unless you want men wearing skirts kilts *bagpipes intensify*),
which brings the total to 12 images.

Actually the hard part would probably be the AI,
you’d need some kind of state machine,
or maybe a decision tree.

Once that’s working, the animations just become part of the state.

You’d probably need quite a lot of images to account for the different character variants…

Unless the characters were done in a sort of Scribblenauts style,
then you could just make the character a skeleton,
and animations would just be batches of transformation values.

To be honest I think the thing I’d have most difficulty with is determining what the characters should actually do.
It takes a lot of time and development to make something as complex as the sims,
and it takes a lot of research and playtesting to make something like that fun.

I think a virtual pet would be a much easier starting point.


Side note, Scribblenauts is a great game:

That’s the trailer for the Switch version, which I don’t have,
but I do have the Steam version.


#12

People behind NAT (same house for example) would get the same characters. But if you had such a server, you could simply increment the seed with each download, that should work just fine.

Or the game could generate the seed at first run (e.g. from the time at which you press the first key), store it into EEPROM and then keep using it. That wouldn’t require any special servers.

What, really? I’d suppose switching to natural skin would only lead to problems with racial correctness nowadays. Keeping them yellow would elegantly avoid them. Besides I liked them yellow as well.

I’d agree to make them yellow.


#13

Depends on the network.

I’m reasonably sure my router has a pool of addresses that it assigns to devices pseudorandomly, so every time my computer connects to the internet I get assigned a pseudorandom address from the same pool of <= 256 addresses.

But some places get a static IP, and others have a smaller pool, so it varies.

I would probably do what Minecraft does - generate a seed per save and offer the chance for the user to input a seed somehow.

I was just saying that the server thing was doable, not that it was necessarily practical.

They switched at least a decade ago.

I think they switched because they ended up having brown and yellow characters alongside each other when they started doing themed sets like Star Wars and Harry Potter, and they decided it looked a bit odd (and/or too much like the Simpsons :P).

Personally I liked the idea that lego characters from the lego universe were just all yellow, I thought it gave them a bit of an alien quality - resembling humans, and yet not quite human.

It would save a few bits, and some palette slots :P


#14

Hmm that’s about when I stopped playing with lego :smile:

The adresses you get from the router are local to your subnet. Unless you have some very special service from your ISP, they put you behind their router that hides all your devices behind the same IP, so from the Internet’s point of view all the devices in your house are the same IP.

That’s what I’d prefer, but generating it behind the scenes would keep that sense of magic for the non-tech savvy people. The effect that makes them think their copy has unique people in it is super cool.


#15

I could have sworn I used to get different IPs reported from different devices.
Maybe they changed that as they ran out of addresses?
(Or maybe I imagined it?)

I’d rather just hide the input box behind a konami code or something.

Either way, the problem with unique people is that unique people need unique sprites, or at the very least an entirely separate generation algorithm.


#16

The address can change over time. Also JavaScript is able to get the local address, so some sites can tell you that (this one tells you both), but the server can’t figure it out from the download request alone.


#17

This is all making me think about something like miis for pokitto, could use a generated little people as your Pokitto profile or something …


#18

They’re still yellow here. Just the knockoff ones are realistic.


#19

Decision tree would be simple just have it check every minute or so (yay rtc) for the values am I hungry, lonely,thirsty, bored whichever has the lowest value gets done, use the 0-15 needs stat and have it count down by one each 1/2 hour or so and when filled it resets


#20

Also this could be two games that work together, one is the house in an sd card the second he little pokitto person.