Merge pull request #182 from WildCodeSchool/release/part-4

Release/part 4

Author: YDrogen

packages/backend/api/src/game/creature/post.buy-creature.ts

@@ -5,30 +5,6 @@ import { db } from '@app/backend-shared';
 
 const postBuyCreature = Router();
 
-// check how many creatures we can unlock in this zone
-function getTotalCreaturesByZone(zoneId: number) {
-  return db
-    .selectFrom('creatures')
-    .select([db.fn.count('creatures.id').as('quantityCreature')])
-    .where('creatures.zone_id', '=', zoneId)
-    .executeTakeFirst();
-}
-
-//check how many creatures user has unlocked in this zone
-function getCreaturesUnlockedByZone(zoneId: number, parkId: number) {
-  return db
-    .selectFrom('park_creatures')
-    .leftJoin('creatures', 'park_creatures.creature_id', 'creatures.id')
-    .select([
-      sql<number>`COUNT(DISTINCT ${sql.ref('park_creatures.creature_id')})`.as(
-        'countCreaturesUnlockedByZone',
-      ),
-    ])
-    .where('creatures.zone_id', '=', zoneId)
-    .where('park_creatures.park_id', '=', parkId)
-    .executeTakeFirst();
-}
-
 //Check if we have already the next zone in bdd
 function getIsNextZoneUnlocked(parkId: number, zoneId: number) {
   return db
@@ -161,12 +137,7 @@ postBuyCreature.post('/buy', async (req: Request, res) => {
     })
     .executeTakeFirst();
 
-  const [isNextZoneUnlocked] = await Promise.all([
-    getTotalCreaturesByZone(zoneId),
-    getCreaturesUnlockedByZone(zoneId, parkId),
-    getIsNextZoneUnlocked(parkId, zoneId),
-  ]);
-
+  const isNextZoneUnlocked = await getIsNextZoneUnlocked(parkId, zoneId);
   const zone = await db
     .selectFrom('zones')
     .select(['name'])

packages/backend/api/src/game/get.gift.ts

@@ -0,0 +1,241 @@
+import { type Request, Router } from 'express';
+import { sql } from 'kysely';
+
+import { db } from '@app/backend-shared';
+import { generateName } from '@app/shared';
+
+const getGiftRoute = Router();
+
+//check if last received gift more than 24h
+function getLastGift(parkId: number) {
+  return db
+    .selectFrom('park_gifts')
+    .select(['gift_date'])
+    .where('park_id', '=', parkId)
+    .where('gift_date', '>', sql<Date>`NOW() - INTERVAL 24 HOUR`)
+    .execute();
+}
+
+//function insert into parks_gift
+async function insertGift(parkId: number, type: string, value: string) {
+  await db
+    .insertInto('park_gifts')
+    .values({
+      type,
+      gift_date: sql`NOW()`,
+      value,
+      park_id: parkId,
+    })
+    .executeTakeFirst();
+}
+
+//function updateWllet
+async function updateWallet(parkId: number, amount: number) {
+  await db
+    .updateTable('parks')
+    .set((eb) => ({
+      wallet: eb('wallet', '+', amount),
+    }))
+    .where('id', '=', parkId)
+    .executeTakeFirst();
+}
+
+type Creature = {
+  id: number;
+  feed_timer: number | null;
+  src_image: string | null;
+  species: string;
+};
+
+//function insert creature into park_creatures
+async function insertCreatureToPark(parkId: number, creature: Creature) {
+  const name = generateName();
+  const gender = Math.random() < 0.5 ? 'male' : 'female';
+
+  await db
+    .insertInto('park_creatures')
+    .values({
+      name,
+      gender,
+      is_adult: 1,
+      is_parent: 0,
+      feed_date: sql`NOW() + INTERVAL ${creature.feed_timer} MINUTE`,
+      adult_at: sql`NOW()`,
+      park_id: parkId,
+      creature_id: creature.id,
+    })
+    .executeTakeFirst();
+}
+
+type Visitor = {
+  id: number;
+  category: string;
+  src_image: string | null;
+};
+
+//function insert visitor into park_visitors
+async function insertVisitorToPark(parkId: number, visitor: Visitor) {
+  await db
+    .insertInto('park_visitors')
+    .values({
+      entry_time: sql`NOW()`,
+      exit_time: sql`NOW() + INTERVAL 4 HOUR`,
+      park_id: parkId,
+      visitor_id: visitor.id,
+    })
+    .executeTakeFirst();
+}
+
+getGiftRoute.get('/gift', async (req: Request, res) => {
+  const parkId = req.parkId;
+  if (parkId === undefined) {
+    res.json({
+      ok: false,
+    });
+    return;
+  }
+
+  const lastGift = await getLastGift(parkId);
+
+  //if last gift less than 24H
+  if (lastGift.length > 0) {
+    res.json({
+      ok: false,
+      message: 'Too soon for a new gift.',
+    });
+    return;
+  }
+
+  const gifts = ['creature', 'visitor', 'moons'];
+  const giftType = gifts[Math.floor(Math.random() * gifts.length)];
+
+  //if creature is drawn
+  if (giftType === 'creature') {
+    //check unlocked creatures
+    const creatures = await db
+      .selectFrom('park_creatures')
+      .innerJoin('creatures', 'creatures.id', 'park_creatures.creature_id')
+      .select([
+        'creatures.id',
+        'creatures.feed_timer',
+        'creatures.src_image',
+        'creatures.species',
+      ])
+      .where('park_id', '=', parkId)
+      .distinct()
+      .execute();
+
+    //if no creature unlocked yet insert a default creature
+    if (creatures.length === 0) {
+      const defaultCreature = await db
+        .selectFrom('creatures')
+        .select(['id', 'species', 'feed_timer', 'src_image'])
+        .where('id', '=', 1)
+        .executeTakeFirst();
+
+      if (defaultCreature === undefined) {
+        res.json({
+          ok: false,
+          message: 'no creature available',
+        });
+        return;
+      }
+
+      await insertGift(parkId, 'creature', defaultCreature.species);
+      await insertCreatureToPark(parkId, defaultCreature);
+    }
+
+    //else draw a creature from the unlocked ones
+    const chosen = creatures[Math.floor(Math.random() * creatures.length)];
+
+    await insertGift(parkId, 'creature', chosen.species);
+    await insertCreatureToPark(parkId, chosen);
+
+    res.json({
+      ok: true,
+      gift: {
+        type: 'creature',
+        creatureId: chosen.id,
+        image: chosen.src_image,
+      },
+    });
+    return;
+  }
+
+  //if visitor is drawn
+  if (giftType === 'visitor') {
+    //check unlocked visitors
+    const visitors = await db
+      .selectFrom('park_visitors')
+      .innerJoin('visitors', 'visitors.zone_id', 'park_visitors.visitor_id')
+      .select([
+        'visitors.id',
+        'visitors.category',
+        'visitors.src_image',
+        'visitors.entry_price',
+      ])
+      .where('park_id', '=', parkId)
+      .distinct()
+      .execute();
+
+    //if no visitors unlocked yet insert a default visitor
+    if (visitors.length === 0) {
+      const defaultVisitor = await db
+        .selectFrom('visitors')
+        .select(['id', 'category', 'src_image', 'entry_price'])
+        .where('id', '=', 1)
+        .executeTakeFirst();
+
+      if (defaultVisitor === undefined) {
+        res.json({
+          ok: false,
+          message: 'no creature available',
+        });
+        return;
+      }
+
+      await insertGift(parkId, 'visitor', `visitor-${defaultVisitor.category}`);
+      await insertVisitorToPark(parkId, defaultVisitor);
+      await updateWallet(parkId, defaultVisitor.entry_price);
+    }
+
+    //else draw a visitor from the unlocked ones
+    const chosen = visitors[Math.floor(Math.random() * visitors.length)];
+
+    await insertGift(parkId, 'visitor', `visitor-${chosen.category}`);
+    await insertVisitorToPark(parkId, chosen);
+    await updateWallet(parkId, chosen.entry_price);
+
+    res.json({
+      ok: true,
+      gift: {
+        type: 'visitor',
+        creatureId: chosen.category,
+        image: chosen.src_image,
+      },
+    });
+    return;
+  }
+
+  //if moons is drawn
+  if (giftType === 'moons') {
+    const amounts = [500, 1000, 1500, 2000];
+    const prize = amounts[Math.floor(Math.random() * amounts.length)];
+
+    await insertGift(parkId, 'moons', String(prize));
+    await updateWallet(parkId, prize);
+
+    res.json({
+      ok: true,
+      gift: {
+        type: 'moons',
+        moons: prize,
+      },
+    });
+    return;
+  }
+
+  res.json({ ok: false });
+});
+
+export default getGiftRoute;

packages/backend/api/src/game/get.wallet.ts

@@ -29,6 +29,14 @@ getWallet.get('/wallet', async (req: Request, res) => {
     return;
   }
 
+  if (park.wallet === null) {
+    res.json({
+      ok: false,
+      message: 'no wallet for this user',
+    });
+    return;
+  }
+
   res.json({
     ok: true,
     park,

packages/backend/api/src/game/get.zones-count.ts

@@ -18,6 +18,7 @@ function getZones(parkId: number) {
       'zones.src_image',
       'zones.link',
       'park_zones.id as park_zone_id',
+      'zones.required_qty',
     ])
     .execute();
 }

packages/backend/api/src/game/index.ts

@@ -8,6 +8,7 @@ import getAvatars from './get.avatars';
 import getCreaturesMenuRoute from './get.creatures-menu';
 import getDecorations from './get.decorations';
 import getEnclosures from './get.enclosures';
+import getGiftRoute from './get.gift';
 import getLeaderboardRoute from './get.leaderboard';
 import getParkUser from './get.park-user';
 import getWallet from './get.wallet';
@@ -30,5 +31,6 @@ gameRouter.use('/visitors', visitorRouter);
 gameRouter.use(getLeaderboardRoute);
 gameRouter.use(getAvatars);
 gameRouter.use(getCreaturesMenuRoute);
+gameRouter.use(getGiftRoute);
 
 export default gameRouter;

packages/backend/migrations/src/migrations/20250617-add-unlock-zone.ts

@@ -0,0 +1,23 @@
+import { type Kysely, sql } from 'kysely';
+
+import type { DB } from '@app/shared';
+
+export async function up(db: Kysely<DB>): Promise<void> {
+  // Migration code that update the database to the desired state.
+  await db.transaction().execute(async (trx) => {
+    await sql`
+      ALTER TABLE zones
+      ADD COLUMN required_qty INT NOT NULL;
+    `.execute(trx);
+  });
+}
+
+export async function down(db: Kysely<DB>): Promise<void> {
+  // Migration code that reverts the database to the previous state.
+  await db.transaction().execute(async (trx) => {
+    await sql`
+      ALTER TABLE zones
+      DROP COLUMN required_qty;
+    `.execute(trx);
+  });
+}

packages/frontend/web/src/components/barrier.tsx

@@ -19,7 +19,7 @@ type BarrierProps = {
 };
 
 export default function Barrier({ barrier, refetch }: BarrierProps) {
-  const { wallet, walletRefetch } = useGameInfoContext();
+  const { wallet, refetchWallet } = useGameInfoContext();
   const hasEnoughMoons = wallet >= barrier.price;
   const priceFormatted = formatNumber(barrier.price);
 
@@ -41,7 +41,7 @@ export default function Barrier({ barrier, refetch }: BarrierProps) {
 
       if (result.ok === true) {
         await refetch();
-        await walletRefetch();
+        await refetchWallet();
       }
     } catch (error) {
       // eslint-disable-next-line no-console

packages/frontend/web/src/components/bg-menu.tsx

@@ -6,7 +6,7 @@ type BgMenuProps = PropsWithChildren;
 export default function BgMenu({ children }: BgMenuProps) {
   return (
     <div
-      className='bg-primary-gray rounded p-3 shadow-[0px_4px_4px_rgba(0,0,0,0.25)] md:rounded-md md:p-6'
+      className='bg-primary-gray rounded p-2 shadow-[0px_4px_4px_rgba(0,0,0,0.25)] md:rounded-md md:p-4'
       style={{ backgroundImage: `url(${BgPattern})` }}
     >
       {children}