News:
September 5th, 2025- Maintenance Complete and Update!

Eternia's Greatest Disppointment | Registered: Mar 14, 2021 03:06

Watch

Avatar by xinjinmeng

🔞

Commissions Are Closed


Opening again in October 



Join here for instant customer service

👇

🏴 https://discord.gg/Nfu3Y82ADX 🚩

Featured Submission

Gallery

Favorites

Recent Watchers

RenFuchsfein	kayodesu0101	Theidiotintheback
Edragon	Name0001	Lucky_the_Eevee_Prince
Frisky	E.A	saccharinesilk
Seven Seas but WEIRD	Infernous_Enox	Tallow

Recently Watched

Proteu5

Astroturf

Stats

Views: 151590
Submissions: 819
Favs: 77359

Comments Earned: 2861
Comments Made: 300
Journals: 12

Featured Journal

Goose Game

2 months ago

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Goose Game</title>
<style>
body {
margin: 0;
overflow: hidden;
}
canvas {
display: block;
background-color: #75643f;
}
</style>
</head>
<body>
<canvas id="gameCanvas" width="800" height="600"></canvas>

<script>
const canvas = document.getElementById('gameCanvas');
const ctx = canvas.getContext('2d');

let x = canvas.width / 2;
let y = canvas.height / 2;
let radius = 30;
let targetRadius = 30;
const speed = 3;
const scaleSpeed = 1;
const minRadius = 30;
const maxRadius = 300;

let gooseHeadCollider = { x: 0, y: 0, r: 0 };

const keys = {
w: false,
a: false,
s: false,
d: false,
};

const palette = {
'1': 'tan',
'2': 'white',
'3': 'green'
};

const breadSprite = [
"011111111111110",
"112222222111111",
"122222222211111",
"122222222211111",
"012222222111110",
"001222221111100",
"001222221111100",
"001222221111100",
"001222221111100",
"001222221111100",
"001111111111100"
];

const vegetableSprite = [
"0000333330000",
"0033333333300",
"0333333333330",
"3333303033333",
"3333003003333",
"0303303033030",
"0000333330000",
"0000033300000",
"0000033300000",
"0000033300000",
"0000033300000"
];

const breads = [];
const vegetables = [];

function getBiasedY(canvasHeight, exponent = 2, reverse = false) {
const r = Math.random();
const biased = reverse ? 1 - Math.pow(r, exponent) : Math.pow(r, exponent);
return biased * canvasHeight;
}

function spawnBread() {
breads.push({
x: canvas.width + 10,
y: getBiasedY(canvas.height, 2, true),
speed: 1,
scale: 2
});
}

function spawnVegetable() {
vegetables.push({
x: canvas.width + 10,
y: getBiasedY(canvas.height, 2, false),
speed: 2,
scale: 2
});
}

setInterval(spawnBread, 500);
setInterval(spawnVegetable, 500);

document.addEventListener('keydown', (e) => {
if (e.key in keys) keys[e.key] = true;
});

document.addEventListener('keyup', (e) => {
if (e.key in keys) keys[e.key] = false;
});

function update() {
// Move breads and update their colliders first
for (const bread of breads) {
bread.x -= bread.speed;

const spriteWidth = breadSprite[0].length * bread.scale;
const spriteHeight = breadSprite.length * bread.scale;
bread.collider = {
x: bread.x + spriteWidth * 0.1,
y: bread.y + spriteHeight * 0.1,
width: spriteWidth * 0.8,
height: spriteHeight * 0.8
};
}

for (const veg of vegetables) {
veg.x -= veg.speed;

const spriteWidth = vegetableSprite[0].length * veg.scale;
const spriteHeight = vegetableSprite.length * veg.scale;
veg.collider = {
x: veg.x + spriteWidth * 0.1,
y: veg.y + spriteHeight * 0.1,
width: spriteWidth * 0.8,
height: spriteHeight * 0.8
};
}

// Now check for collisions and remove sprites
for (let i = breads.length - 1; i >= 0; i--) {
const bread = breads[i];
const dx = gooseHeadCollider.x - (bread.collider.x + bread.collider.width / 2);
const dy = gooseHeadCollider.y - (bread.collider.y + bread.collider.height / 2);
const dist = Math.sqrt(dx * dx + dy * dy);
if (dist < gooseHeadCollider.r + Math.min(bread.collider.width, bread.collider.height) / 2) {
breads.splice(i, 1);
targetRadius += 10; // Increase target radius
}
}

for (let i = vegetables.length - 1; i >= 0; i--) {
const veg = vegetables[i];
const dx = gooseHeadCollider.x - (veg.collider.x + veg.collider.width / 2);
const dy = gooseHeadCollider.y - (veg.collider.y + veg.collider.height / 2);
const dist = Math.sqrt(dx * dx + dy * dy);
if (dist < gooseHeadCollider.r + Math.min(veg.collider.width, veg.collider.height) / 2) {
vegetables.splice(i, 1);
targetRadius = Math.max(minRadius, targetRadius - 30);
}
}

// Movement controls
if (keys.w) y -= speed;
if (keys.s) y += speed;
if (keys.a) x -= speed;
if (keys.d) x += speed;

// Smoothly interpolate radius toward targetRadius
radius += (targetRadius - radius) * 0.1;
radius = Math.max(minRadius, Math.min(maxRadius, radius));
x = Math.max(radius, Math.min(canvas.width - radius, x));
y = Math.max(radius, Math.min(canvas.height - radius, y));

for (const bread of breads) {
bread.x -= bread.speed;

// Bread box collider (slightly smaller than sprite)
const spriteWidth = breadSprite[0].length * bread.scale;
const spriteHeight = breadSprite.length * bread.scale;
bread.collider = {
x: bread.x + spriteWidth * 0.1,
y: bread.y + spriteHeight * 0.1,
width: spriteWidth * 0.8,
height: spriteHeight * 0.8
};
}

for (const veg of vegetables) {
veg.x -= veg.speed;

// Vegetable box collider (slightly smaller than sprite)
const spriteWidth = vegetableSprite[0].length * veg.scale;
const spriteHeight = vegetableSprite.length * veg.scale;
veg.collider = {
x: veg.x + spriteWidth * 0.1,
y: veg.y + spriteHeight * 0.1,
width: spriteWidth * 0.8,
height: spriteHeight * 0.8
};
}
}

function drawGoose() {
ctx.beginPath();
ctx.arc(x, y, radius, 0, Math.PI * 2);
ctx.fillStyle = 'white';
ctx.fill();

const angle = -Math.PI / 2;
const headDistance = radius + 16;
const headX = x + Math.cos(angle) * headDistance;
const headY = y + Math.sin(angle) * headDistance;

const neckWidth = 10;
const neckHeight = 20;

ctx.save();
ctx.translate(headX, headY);
ctx.rotate(angle + Math.PI / 2);
ctx.fillStyle = 'white';
ctx.fillRect(-neckWidth / 2, 0, neckWidth, neckHeight);
ctx.restore();

const headRadius = 12;
ctx.beginPath();
ctx.arc(headX, headY, headRadius, 0, Math.PI * 2);
ctx.fillStyle = 'white';
ctx.fill();

const localBeakPoints = [
{ x: -6, y: 25 },
{ x: -6, y: 10 },
{ x: 6, y: 11 }
];

const rotatedPoints = localBeakPoints.map(p => {
const rotatedX = p.x * Math.cos(angle) - p.y * Math.sin(angle);
const rotatedY = p.x * Math.sin(angle) + p.y * Math.cos(angle);
return {
x: headX + rotatedX,
y: headY + rotatedY
};
});

ctx.beginPath();
ctx.moveTo(rotatedPoints[0].x, rotatedPoints[0].y);
ctx.lineTo(rotatedPoints[1].x, rotatedPoints[1].y);
ctx.lineTo(rotatedPoints[2].x, rotatedPoints[2].y);
ctx.closePath();
ctx.fillStyle = 'orange';
ctx.fill();

ctx.beginPath();
ctx.arc(headX + 3, headY - 3, 2, 0, Math.PI * 2);
ctx.fillStyle = 'black';
ctx.fill();

drawPixelBow(ctx, headX - 12, headY + 16, 2);

// Head collider for use in logic or debugging
gooseHeadCollider = {
x: headX,
y: headY,
r: headRadius
};
}

function drawPixelBow(ctx, startX, startY, scale = 2) {
const bowPixels = [
"0111011101110",
"1111111111111",
"1111111111111",
"0110110110110",
"0000110110000",
"0001110111000",
"0011100011100",
"0001100011000"
];

ctx.fillStyle = '#57aeff';

for (let row = 0; row < bowPixels.length; row++) {
for (let col = 0; col < bowPixels[row].length; col++) {
if (bowPixels[row][col] === '1') {
ctx.fillRect(startX + col * scale, startY + row * scale, scale, scale);
}
}
}
}

function drawPolkaDots(ctx, canvasWidth, canvasHeight, spacing = 40, dotRadius = 4) {
ctx.fillStyle = 'white';

for (let row = 0, y = 0; y < canvasHeight; row++, y += spacing) {
const isOddRow = row % 2 === 1;
const xOffset = isOddRow ? spacing / 2 : 0;

for (let x = 0; x < canvasWidth; x += spacing) {
ctx.beginPath();
ctx.arc(x + xOffset, y, dotRadius, 0, Math.PI * 2);
ctx.fill();
}
}
}

function drawSprite(ctx, pixelData, startX, startY, scale = 2, palette = {}) {
for (let row = 0; row < pixelData.length; row++) {
for (let col = 0; col < pixelData[row].length; col++) {
const code = pixelData[row][col];
const color = palette[code];

if (color) {
ctx.fillStyle = color;
ctx.fillRect(startX + col * scale, startY + row * scale, scale, scale);
}
}
}
}

function draw() {
ctx.fillStyle = '#94bce0';
ctx.fillRect(0, 0, canvas.width, canvas.height);
drawPolkaDots(ctx, canvas.width, canvas.height, 49, 2);
drawGoose();

for (const bread of breads) {
drawSprite(ctx, breadSprite, bread.x, bread.y, bread.scale, palette);
}

for (const veg of vegetables) {
drawSprite(ctx, vegetableSprite, veg.x, veg.y, veg.scale, palette);
}
}

function gameLoop() {
update();
draw();
requestAnimationFrame(gameLoop);
}

gameLoop();
</script>
</body>
</html>

User Profile

Accepting Trades

Accepting Commissions

Yes

Character Species

Country Goose

Favorite Music

The Ethel Merman Disco Album

Favorite Games

The sport of chumps

Favorite Animals

If my mother knew I did this for a living, she'd kill me. She thinks I'm selling dope.

Favorite Foods & Drinks

Bread

Favorite Quote

Whither shall I wander?

Tallow ~themusicbird

a week ago

ROADRUNNA????

Logan~Wulf ~logan~wulf

3 weeks ago

I really love your inflation work so I made this lol https://www.furaffinity.net/view/61996364/

BabClayton ~babclayton

5 months ago

Hello.
I have made an Image, based on your "Antarctic Antics" Comics
https://www.furaffinity.net/view/60432420/
I hope you like.

I also notice you say Commissions opening soon. You have a price sheet available, Please?