387 lines
14 KiB
TypeScript
387 lines
14 KiB
TypeScript
import { PrismaClient, User, Village, VillageTile, VillageObject, Prisma } from '@prisma/client';
|
|
import { COSTS, REWARDS } from '../utils/economy';
|
|
|
|
const prisma = new PrismaClient();
|
|
|
|
export const VILLAGE_WIDTH = 5;
|
|
export const VILLAGE_HEIGHT = 7;
|
|
const CLEANING_TIME = 24 * 60 * 60 * 1000; // 24 hours
|
|
|
|
export const PRODUCING_BUILDINGS: string[] = [
|
|
'FIELD',
|
|
'LUMBERJACK',
|
|
'QUARRY',
|
|
];
|
|
|
|
// Helper to get the start of a given date for daily EXP checks
|
|
const getStartOfDay = (date: Date) => {
|
|
const d = new Date(date);
|
|
d.setUTCHours(0, 0, 0, 0); // Use UTC for calendar day consistency
|
|
return d;
|
|
};
|
|
|
|
/**
|
|
* Generates the initial village for a new user atomically.
|
|
*/
|
|
export async function generateVillageForUser(user: User) {
|
|
const existingVillage = await prisma.village.findUnique({
|
|
where: { userId: user.id },
|
|
});
|
|
|
|
if (existingVillage) {
|
|
return;
|
|
}
|
|
|
|
const tilesToCreate: Omit<VillageTile, 'id' | 'clearingStartedAt' | 'villageId'>[] = [];
|
|
const central_x_start = 1;
|
|
const central_x_end = 4;
|
|
const central_y_start = 2;
|
|
const central_y_end = 5;
|
|
|
|
for (let y = 0; y < VILLAGE_HEIGHT; y++) {
|
|
for (let x = 0; x < VILLAGE_WIDTH; x++) {
|
|
const isCentral = x >= central_x_start && x < central_x_end && y >= central_y_start && y < central_y_end;
|
|
const terrainType = isCentral
|
|
? 'EMPTY'
|
|
: Math.random() < 0.5 ? 'BLOCKED_TREE' : 'BLOCKED_STONE';
|
|
|
|
tilesToCreate.push({
|
|
x,
|
|
y,
|
|
terrainType,
|
|
terrainState: 'IDLE',
|
|
});
|
|
}
|
|
}
|
|
|
|
// FIX: Wrap village generation in a single transaction for atomicity.
|
|
await prisma.$transaction(async (tx) => {
|
|
const village = await tx.village.create({
|
|
data: {
|
|
userId: user.id,
|
|
},
|
|
});
|
|
|
|
await tx.user.update({
|
|
where: { id: user.id },
|
|
data: {
|
|
coins: 10,
|
|
exp: 0,
|
|
},
|
|
});
|
|
|
|
await tx.villageTile.createMany({
|
|
data: tilesToCreate.map(tile => ({ ...tile, villageId: village.id })),
|
|
});
|
|
});
|
|
}
|
|
|
|
type FullVillage = Prisma.VillageGetPayload<{
|
|
include: {
|
|
user: true;
|
|
tiles: { include: { object: true } };
|
|
objects: { include: { tile: true } };
|
|
};
|
|
}>;
|
|
|
|
/**
|
|
* Gets the full, updated state of a user's village, calculating all time-based progression.
|
|
*/
|
|
export async function getVillageState(userId: number): Promise<FullVillage> {
|
|
const now = new Date();
|
|
const { applyStreakMultiplier } = await import('../utils/streak');
|
|
|
|
// --- Step 1: Initial Snapshot ---
|
|
let villageSnapshot = await prisma.village.findUnique({
|
|
where: { userId },
|
|
include: {
|
|
user: true,
|
|
tiles: { include: { object: true } },
|
|
objects: { include: { tile: true } },
|
|
},
|
|
});
|
|
|
|
if (!villageSnapshot) {
|
|
throw createError({ statusCode: 404, statusMessage: 'Village not found' });
|
|
}
|
|
|
|
const userForStreak = villageSnapshot.user;
|
|
|
|
// --- Step 2: Terrain Cleaning Completion ---
|
|
const finishedClearingTiles = villageSnapshot.tiles.filter(
|
|
t => t.terrainState === 'CLEARING' && t.clearingStartedAt && now.getTime() - t.clearingStartedAt.getTime() >= CLEANING_TIME
|
|
);
|
|
|
|
if (finishedClearingTiles.length > 0) {
|
|
// Apply streak multiplier to clearing rewards
|
|
const baseClearingReward = REWARDS.VILLAGE.CLEARING;
|
|
const finalClearingReward = applyStreakMultiplier(baseClearingReward, userForStreak.dailyStreak);
|
|
|
|
const totalCoins = finishedClearingTiles.length * finalClearingReward.coins;
|
|
const totalExp = finishedClearingTiles.length * finalClearingReward.exp;
|
|
|
|
await prisma.$transaction(async (tx) => {
|
|
// 1. Update user totals
|
|
await tx.user.update({
|
|
where: { id: userId },
|
|
data: {
|
|
coins: { increment: totalCoins },
|
|
exp: { increment: totalExp },
|
|
},
|
|
});
|
|
|
|
// 2. Update all the tiles
|
|
await tx.villageTile.updateMany({
|
|
where: { id: { in: finishedClearingTiles.map(t => t.id) } },
|
|
data: { terrainType: 'EMPTY', terrainState: 'IDLE', clearingStartedAt: null },
|
|
});
|
|
|
|
// 3. Create an event for each completed tile with the final reward
|
|
const multiplier = userForStreak.dailyStreak;
|
|
let streakBonusText = '';
|
|
if (multiplier === 2) {
|
|
streakBonusText = ' Ваша серия визитов (x2) удвоила награду!';
|
|
} else if (multiplier >= 3) {
|
|
streakBonusText = ' Ваша серия визитов (x3) утроила награду!';
|
|
}
|
|
|
|
for (const tile of finishedClearingTiles) {
|
|
const resourceName = tile.terrainType === 'BLOCKED_TREE' ? 'дерево' : 'камень';
|
|
const actionText = tile.terrainType === 'BLOCKED_TREE' ? 'Лесоруб расчистил участок' : 'Каменотес раздробил валун';
|
|
|
|
await tx.villageEvent.create({
|
|
data: {
|
|
villageId: villageSnapshot.id,
|
|
type: tile.terrainType === 'BLOCKED_TREE' ? 'CLEAR_TREE' : 'CLEAR_STONE',
|
|
message: `${actionText}, принеся вам ${finalClearingReward.coins} монет и ${finalClearingReward.exp} опыта.${streakBonusText}`,
|
|
tileX: tile.x,
|
|
tileY: tile.y,
|
|
coins: finalClearingReward.coins,
|
|
exp: finalClearingReward.exp,
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
|
|
// --- Step 3: Refetch for next logic step ---
|
|
villageSnapshot = await prisma.village.findUnique({ where: { userId }, include: { user: true, tiles: { include: { object: true } }, objects: { include: { tile: true } } } })!;
|
|
|
|
// --- Step 4: Field EXP Processing ---
|
|
const today = getStartOfDay(now);
|
|
const fieldsForExp = villageSnapshot.objects.filter(
|
|
obj => obj.type === 'FIELD' && (!obj.lastExpAt || getStartOfDay(obj.lastExpAt) < today)
|
|
);
|
|
|
|
if (fieldsForExp.length > 0) {
|
|
const wellPositions = new Set(villageSnapshot.objects.filter(obj => obj.type === 'WELL').map(w => `${w.tile.x},${w.tile.y}`));
|
|
let totalExpFromFields = 0;
|
|
const eventsToCreate = [];
|
|
|
|
for (const field of fieldsForExp) {
|
|
// First, calculate base EXP with existing game logic (well bonus)
|
|
let baseFieldExp = REWARDS.VILLAGE.FIELD_EXP.BASE;
|
|
if (wellPositions.has(`${field.tile.x},${field.tile.y - 1}`) || wellPositions.has(`${field.tile.x},${field.tile.y + 1}`) || wellPositions.has(`${field.tile.x - 1},${field.tile.y}`) || wellPositions.has(`${field.tile.x + 1},${field.tile.y}`)) {
|
|
baseFieldExp *= REWARDS.VILLAGE.FIELD_EXP.WELL_MULTIPLIER;
|
|
}
|
|
|
|
// Now, apply the daily streak multiplier
|
|
const finalFieldExp = applyStreakMultiplier({ coins: 0, exp: baseFieldExp }, userForStreak.dailyStreak).exp;
|
|
|
|
totalExpFromFields += finalFieldExp;
|
|
|
|
const multiplier = userForStreak.dailyStreak;
|
|
let streakBonusText = '';
|
|
if (multiplier === 2) {
|
|
streakBonusText = ' Ваша серия визитов (x2) удвоила урожай опыта!';
|
|
} else if (multiplier >= 3) {
|
|
streakBonusText = ' Ваша серия визитов (x3) утроила урожай опыта!';
|
|
}
|
|
|
|
eventsToCreate.push({
|
|
villageId: villageSnapshot.id,
|
|
type: 'FIELD_EXP',
|
|
message: `Поле (${field.tile.x}, ${field.tile.y}) плодоносит, принося вам ${finalFieldExp} опыта.${streakBonusText}`,
|
|
tileX: field.tile.x,
|
|
tileY: field.tile.y,
|
|
coins: 0,
|
|
exp: finalFieldExp,
|
|
});
|
|
}
|
|
|
|
await prisma.$transaction([
|
|
prisma.user.update({ where: { id: userId }, data: { exp: { increment: totalExpFromFields } } }),
|
|
prisma.villageObject.updateMany({ where: { id: { in: fieldsForExp.map(f => f.id) } }, data: { lastExpAt: today } }),
|
|
prisma.villageEvent.createMany({ data: eventsToCreate }),
|
|
]);
|
|
}
|
|
|
|
// --- Step 5: Refetch for next logic step ---
|
|
villageSnapshot = await prisma.village.findUnique({ where: { userId }, include: { user: true, tiles: { include: { object: true } }, objects: { include: { tile: true } } } })!;
|
|
|
|
// --- Step 6: Auto-start Terrain Cleaning ---
|
|
const lumberjackCount = villageSnapshot.objects.filter(o => o.type === 'LUMBERJACK').length;
|
|
const quarryCount = villageSnapshot.objects.filter(o => o.type === 'QUARRY').length;
|
|
|
|
const clearingTreesCount = villageSnapshot.tiles.filter(t => t.terrainType === 'BLOCKED_TREE' && t.terrainState === 'CLEARING').length;
|
|
const clearingStonesCount = villageSnapshot.tiles.filter(t => t.terrainType === 'BLOCKED_STONE' && t.terrainState === 'CLEARING').length;
|
|
|
|
const freeLumberjacks = lumberjackCount - clearingTreesCount;
|
|
const freeQuarries = quarryCount - clearingStonesCount;
|
|
|
|
const tileIdsToClear = new Set<number>();
|
|
|
|
if (freeLumberjacks > 0) {
|
|
const idleTrees = villageSnapshot.tiles.filter(t => t.terrainType === 'BLOCKED_TREE' && t.terrainState === 'IDLE');
|
|
if (idleTrees.length > 0) {
|
|
// For simplicity, just take the first N available trees. A more complex distance-based heuristic could go here.
|
|
idleTrees.slice(0, freeLumberjacks).forEach(t => tileIdsToClear.add(t.id));
|
|
}
|
|
}
|
|
|
|
if (freeQuarries > 0) {
|
|
const idleStones = villageSnapshot.tiles.filter(t => t.terrainType === 'BLOCKED_STONE' && t.terrainState === 'IDLE');
|
|
if (idleStones.length > 0) {
|
|
// For simplicity, just take the first N available stones.
|
|
idleStones.slice(0, freeQuarries).forEach(t => tileIdsToClear.add(t.id));
|
|
}
|
|
}
|
|
|
|
if (tileIdsToClear.size > 0) {
|
|
await prisma.villageTile.updateMany({
|
|
where: { id: { in: Array.from(tileIdsToClear) } },
|
|
data: { terrainState: 'CLEARING', clearingStartedAt: now },
|
|
});
|
|
|
|
// Refetch state after starting new clearings
|
|
villageSnapshot = await prisma.village.findUnique({ where: { userId }, include: { user: true, tiles: { include: { object: true } }, objects: { include: { tile: true } } } })!;
|
|
}
|
|
|
|
// --- Step 7: Final Fetch & Action Enrichment ---
|
|
const finalVillageState = await prisma.village.findUnique({
|
|
where: { userId },
|
|
include: {
|
|
user: true,
|
|
tiles: { include: { object: true }, orderBy: [{ y: 'asc' }, { x: 'asc' }] },
|
|
objects: { include: { tile: true } },
|
|
},
|
|
});
|
|
|
|
if (!finalVillageState) {
|
|
throw createError({ statusCode: 404, statusMessage: 'Village not found post-update' });
|
|
}
|
|
|
|
// --- Step 8: Enrich tiles with available actions ---
|
|
const { user } = finalVillageState;
|
|
const hasLumberjack = finalVillageState.objects.some(o => o.type === 'LUMBERJACK');
|
|
const hasQuarry = finalVillageState.objects.some(o => o.type === 'QUARRY');
|
|
|
|
const housesCount = finalVillageState.objects.filter(o => o.type === 'HOUSE').length;
|
|
const producingCount = finalVillageState.objects.filter(o => PRODUCING_BUILDINGS.includes(o.type)).length;
|
|
const freeWorkers = housesCount - producingCount;
|
|
|
|
const tilesWithActions = finalVillageState.tiles.map(tile => {
|
|
const availableActions: any[] = [];
|
|
|
|
// Action: BUILD
|
|
if (tile.terrainType === 'EMPTY' && !tile.object) {
|
|
const buildableObjectTypes = ['HOUSE', 'FIELD', 'LUMBERJACK', 'QUARRY', 'WELL'];
|
|
const buildActions = buildableObjectTypes.map(buildingType => {
|
|
const cost = COSTS.BUILD[buildingType];
|
|
const isProducing = PRODUCING_BUILDINGS.includes(buildingType);
|
|
let isEnabled = user.coins >= cost;
|
|
let disabledReason = user.coins < cost ? 'Not enough coins' : undefined;
|
|
|
|
if (isEnabled && isProducing && freeWorkers <= 0) {
|
|
isEnabled = false;
|
|
disabledReason = 'Not enough workers';
|
|
}
|
|
|
|
return {
|
|
type: 'BUILD',
|
|
buildingType,
|
|
cost,
|
|
isEnabled,
|
|
disabledReason,
|
|
};
|
|
});
|
|
availableActions.push(...buildActions);
|
|
}
|
|
|
|
if (tile.object) {
|
|
// MOVE and REMOVE actions have been removed as per the refactor request.
|
|
}
|
|
|
|
return { ...tile, availableActions };
|
|
});
|
|
|
|
return { ...finalVillageState, tiles: tilesWithActions } as any;
|
|
}
|
|
|
|
// --- Action Service Functions ---
|
|
|
|
export async function buildOnTile(userId: number, tileId: number, buildingType: string) {
|
|
const { VillageObjectType } = await import('@prisma/client');
|
|
const validBuildingTypes = Object.keys(VillageObjectType);
|
|
if (!validBuildingTypes.includes(buildingType)) {
|
|
throw createError({ statusCode: 400, statusMessage: `Invalid building type: ${buildingType}` });
|
|
}
|
|
|
|
return prisma.$transaction(async (tx) => {
|
|
// 1. Fetch all necessary data
|
|
const user = await tx.user.findUniqueOrThrow({ where: { id: userId } });
|
|
const tile = await tx.villageTile.findUniqueOrThrow({ where: { id: tileId }, include: { village: true } });
|
|
|
|
// Ownership check
|
|
if (tile.village.userId !== userId) {
|
|
throw createError({ statusCode: 403, statusMessage: "You don't own this tile" });
|
|
}
|
|
|
|
// Business logic validation
|
|
if (tile.terrainType !== 'EMPTY' || tile.object) {
|
|
throw createError({ statusCode: 400, statusMessage: 'Tile is not empty' });
|
|
}
|
|
|
|
const cost = COSTS.BUILD[buildingType];
|
|
if (user.coins < cost) {
|
|
throw createError({ statusCode: 400, statusMessage: 'Not enough coins' });
|
|
}
|
|
|
|
if (PRODUCING_BUILDINGS.includes(buildingType)) {
|
|
const villageObjects = await tx.villageObject.findMany({ where: { villageId: tile.villageId } });
|
|
const housesCount = villageObjects.filter(o => o.type === 'HOUSE').length;
|
|
const producingCount = villageObjects.filter(o => PRODUCING_BUILDINGS.includes(o.type)).length;
|
|
if (producingCount >= housesCount) {
|
|
throw createError({ statusCode: 400, statusMessage: 'Not enough workers (houses)' });
|
|
}
|
|
}
|
|
|
|
// 2. Perform mutations
|
|
await tx.user.update({
|
|
where: { id: userId },
|
|
data: { coins: { decrement: cost } },
|
|
});
|
|
|
|
await tx.villageObject.create({
|
|
data: {
|
|
type: buildingType as keyof typeof VillageObjectType,
|
|
villageId: tile.villageId,
|
|
tileId: tileId,
|
|
},
|
|
});
|
|
|
|
await tx.villageEvent.create({
|
|
data: {
|
|
villageId: tile.villageId,
|
|
type: `BUILD_${buildingType}`,
|
|
message: `Built a ${buildingType} at (${tile.x}, ${tile.y})`,
|
|
tileX: tile.x,
|
|
tileY: tile.y,
|
|
coins: -cost,
|
|
exp: 0,
|
|
},
|
|
});
|
|
});
|
|
}
|
|
|
|
|