620 lines
22 KiB
JavaScript
620 lines
22 KiB
JavaScript
// ==================== 3D РЕНДЕР (Three.js) — GrechkaCraft v2 ====================
|
||
// Логика, физика, сеть, инвентарь, крафт, погода — из src3d (общие модули).
|
||
// Здесь ТОЛЬКО отрисовка: 2D-canvas заменён на Three.js-сцену.
|
||
//
|
||
// Единицы: 1 тайл = 1 юнит. Игровые координаты px: +y ВНИЗ.
|
||
// Three.js: +y ВВЕРХ, +z к зрителю. Поэтому TY(v) = -v / TILE.
|
||
import { state } from '../core/state.js';
|
||
import { BLOCKS } from '../data/blocks.js';
|
||
import { getBiome } from '../world/generation.js';
|
||
import { isNight } from '../entities/mob-ai.js';
|
||
import { skyColor } from '../world/weather.js';
|
||
import { mode } from '../game/modes.js';
|
||
import { handleTap, stopMining } from '../input/mouse-handler.js';
|
||
import { HERO_COL, HERO_PARTS, HERO_PIVOT, HERO_SCALE } from './hero-rig.js';
|
||
|
||
const TDY = (v) => -v / state.TILE;
|
||
|
||
let TD = null; // движок; создаётся на первом кадре
|
||
|
||
// ---------- материалы блоков ----------
|
||
function TDparseColor(c) {
|
||
const m = /rgba?\(([^)]+)\)/.exec(c);
|
||
if (!m) return { color: new THREE.Color(c), opacity: 1 };
|
||
const p = m[1].split(',').map(s => parseFloat(s));
|
||
return { color: new THREE.Color(p[0] / 255, p[1] / 255, p[2] / 255), opacity: p.length > 3 ? p[3] : 1 };
|
||
}
|
||
|
||
function TDblockMat(t) {
|
||
const def = BLOCKS[t] || {};
|
||
const { color, opacity } = TDparseColor(def.c || '#ff00ff');
|
||
const a = def.alpha !== undefined ? def.alpha : opacity;
|
||
return new THREE.MeshLambertMaterial({ color, transparent: a < 1, opacity: a });
|
||
}
|
||
|
||
function TDisFluid(t) { const d = BLOCKS[t]; return !!(d && d.fluid); }
|
||
function TDisDecor(t) {
|
||
const d = BLOCKS[t];
|
||
if (!d) return false;
|
||
return !d.solid || !!d.decor || !!d.climbable;
|
||
}
|
||
|
||
// ---------- герой: тот же пиксельный рисунок, собранный из кубиков ----------
|
||
function TDbuildHeroRig() {
|
||
const group = new THREE.Group();
|
||
const P = {};
|
||
const MAT = {};
|
||
for (const k of Object.keys(HERO_COL)) MAT[k] = new THREE.MeshLambertMaterial({ color: HERO_COL[k].hex });
|
||
for (const name of Object.keys(HERO_PARTS)) {
|
||
const g = new THREE.Group();
|
||
const j = HERO_PIVOT[name];
|
||
g.position.set(j[0] * HERO_SCALE, j[1] * HERO_SCALE, 0);
|
||
const inner = new THREE.Group();
|
||
inner.position.set(-j[0] * HERO_SCALE, -j[1] * HERO_SCALE, 0);
|
||
g.add(inner);
|
||
group.add(g);
|
||
P[name] = g;
|
||
for (const r of HERO_PARTS[name]) {
|
||
const depth = HERO_COL[r[4]].d * HERO_SCALE;
|
||
const m = new THREE.Mesh(
|
||
new THREE.BoxGeometry(r[2] * HERO_SCALE, r[3] * HERO_SCALE, depth),
|
||
MAT[r[4]]
|
||
);
|
||
m.position.set((r[0] - 0.24) * HERO_SCALE, r[1] * HERO_SCALE, depth / 2);
|
||
m.castShadow = true;
|
||
m.receiveShadow = true;
|
||
inner.add(m);
|
||
}
|
||
}
|
||
return { group, P };
|
||
}
|
||
|
||
const TD_MOB_COLORS = {
|
||
zombie: 0x2ecc71, pig: 0xffb6c1, chicken: 0xecf0f1, creeper: 0x4caf50,
|
||
skeleton: 0xeceff1, scorpion: 0x5d4037, polar_bear: 0xeceff1,
|
||
slime: 0x4caf50, eagle: 0x5d4037,
|
||
};
|
||
|
||
function TDnameSprite(name) {
|
||
const cv = document.createElement('canvas');
|
||
cv.width = 256; cv.height = 48;
|
||
const g = cv.getContext('2d');
|
||
g.font = 'bold 26px system-ui';
|
||
g.textAlign = 'center';
|
||
g.fillStyle = 'rgba(0,0,0,0.45)';
|
||
g.fillRect(0, 0, 256, 48);
|
||
g.fillStyle = '#fff';
|
||
g.fillText(String(name || '?').slice(0, 14), 128, 33);
|
||
const sp = new THREE.Sprite(new THREE.SpriteMaterial({ map: new THREE.CanvasTexture(cv), depthTest: false }));
|
||
sp.scale.set(2.2, 0.41, 1);
|
||
return sp;
|
||
}
|
||
|
||
// ---------- init ----------
|
||
function TDinit() {
|
||
const canvas = state.canvas;
|
||
const renderer = new THREE.WebGLRenderer({ canvas, antialias: true });
|
||
if (renderer.outputEncoding !== undefined && THREE.sRGBEncoding !== undefined) {
|
||
renderer.outputEncoding = THREE.sRGBEncoding;
|
||
}
|
||
renderer.shadowMap.enabled = true;
|
||
renderer.shadowMap.type = THREE.PCFShadowMap;
|
||
|
||
const scene = new THREE.Scene();
|
||
scene.background = new THREE.Color(0x8fc7f5);
|
||
scene.fog = new THREE.Fog(0x8fc7f5, 40, 110);
|
||
const camera = new THREE.PerspectiveCamera(55, 1, 0.1, 400);
|
||
|
||
const hemi = new THREE.HemisphereLight(0xcfe6ff, 0x6ab04c, 0.9);
|
||
const sun = new THREE.DirectionalLight(0xffffff, 1.5);
|
||
sun.castShadow = true;
|
||
sun.shadow.mapSize.set(1024, 1024);
|
||
sun.shadow.camera.left = -32; sun.shadow.camera.right = 32;
|
||
sun.shadow.camera.top = 32; sun.shadow.camera.bottom = -32;
|
||
sun.shadow.camera.near = 1; sun.shadow.camera.far = 180;
|
||
sun.shadow.normalBias = 0.05;
|
||
const amb = new THREE.AmbientLight(0xffffff, 0.25);
|
||
scene.add(hemi, sun, sun.target, amb);
|
||
|
||
const hero = TDbuildHeroRig();
|
||
scene.add(hero.group);
|
||
|
||
// Стена за миром и пол — дают толщину сцене (мир по Z = 1 тайл)
|
||
const backWall = new THREE.Mesh(
|
||
new THREE.PlaneGeometry(600, 400),
|
||
new THREE.MeshBasicMaterial({ color: 0x2b3a2a })
|
||
);
|
||
backWall.position.set(0, 0, -2.5);
|
||
backWall.frustumCulled = false;
|
||
scene.add(backWall);
|
||
const groundPlane = new THREE.Mesh(
|
||
new THREE.PlaneGeometry(600, 400),
|
||
new THREE.MeshLambertMaterial({ color: 0x3d5a3a })
|
||
);
|
||
groundPlane.rotation.x = -Math.PI / 2;
|
||
groundPlane.position.set(0, 0, 3);
|
||
groundPlane.frustumCulled = false;
|
||
groundPlane.receiveShadow = true;
|
||
scene.add(groundPlane);
|
||
|
||
const crack = new THREE.Mesh(
|
||
new THREE.BoxGeometry(1.003, 1.003, 1.003),
|
||
new THREE.MeshBasicMaterial({ color: 0x000000, transparent: true, opacity: 0 })
|
||
);
|
||
crack.visible = false;
|
||
scene.add(crack);
|
||
|
||
const ghost = new THREE.Mesh(
|
||
new THREE.BoxGeometry(1.01, 1.01, 1.01),
|
||
new THREE.MeshBasicMaterial({ color: 0xffffff, wireframe: true, transparent: true, opacity: 0.9 })
|
||
);
|
||
ghost.visible = false;
|
||
scene.add(ghost);
|
||
|
||
// облака
|
||
const cloudMeshes = [];
|
||
const cloudMat = new THREE.MeshLambertMaterial({ color: 0xffffff, transparent: true, opacity: 0.8 });
|
||
for (let i = 0; i < 14; i++) {
|
||
const m = new THREE.Mesh(new THREE.BoxGeometry(4, 0.7, 1.5), cloudMat);
|
||
scene.add(m);
|
||
cloudMeshes.push(m);
|
||
}
|
||
|
||
// снаряды
|
||
const projPool = [];
|
||
for (let i = 0; i < 24; i++) {
|
||
const m = new THREE.Mesh(new THREE.BoxGeometry(0.6, 0.09, 0.09), new THREE.MeshBasicMaterial({ color: 0xf1c40f }));
|
||
m.visible = false;
|
||
scene.add(m);
|
||
projPool.push(m);
|
||
}
|
||
|
||
// частицы
|
||
const PMAX = 600;
|
||
const pGeo = new THREE.BufferGeometry();
|
||
const pPos = new Float32Array(PMAX * 3);
|
||
const pCol = new Float32Array(PMAX * 3);
|
||
pGeo.setAttribute('position', new THREE.BufferAttribute(pPos, 3));
|
||
pGeo.setAttribute('color', new THREE.BufferAttribute(pCol, 3));
|
||
const points = new THREE.Points(pGeo, new THREE.PointsMaterial({ size: 0.14, vertexColors: true, depthWrite: false }));
|
||
points.frustumCulled = false;
|
||
scene.add(points);
|
||
|
||
// дождь / снег
|
||
function makeFall(n, color, size) {
|
||
const g = new THREE.BufferGeometry();
|
||
const pos = new Float32Array(n * 3);
|
||
g.setAttribute('position', new THREE.BufferAttribute(pos, 3));
|
||
const pts = new THREE.Points(g, new THREE.PointsMaterial({ color, size, transparent: true, opacity: 0.7, depthWrite: false }));
|
||
pts.frustumCulled = false;
|
||
pts.visible = false;
|
||
scene.add(pts);
|
||
return { pts, pos, n };
|
||
}
|
||
const rain = makeFall(400, 0x74b9ff, 0.18);
|
||
const snow = makeFall(250, 0xffffff, 0.15);
|
||
|
||
// огни: точечные свет + конусы пламени
|
||
const lightPool = [];
|
||
for (let i = 0; i < 5; i++) {
|
||
const L = new THREE.PointLight(0xff9a3c, 0, 20);
|
||
scene.add(L);
|
||
lightPool.push(L);
|
||
}
|
||
const flamePool = [];
|
||
for (let i = 0; i < 8; i++) {
|
||
const f = new THREE.Mesh(new THREE.ConeGeometry(0.28, 0.7, 6), new THREE.MeshBasicMaterial({ color: 0xff7a1a }));
|
||
f.visible = false;
|
||
scene.add(f);
|
||
flamePool.push(f);
|
||
}
|
||
|
||
const boatMesh = new THREE.Mesh(
|
||
new THREE.BoxGeometry(1.4, 0.5, 0.8),
|
||
new THREE.MeshLambertMaterial({ color: 0x8b4513 })
|
||
);
|
||
boatMesh.visible = false;
|
||
boatMesh.castShadow = true;
|
||
scene.add(boatMesh);
|
||
|
||
TD = {
|
||
renderer, scene, camera, hemi, sun, amb, hero, backWall, groundPlane,
|
||
crack, ghost, cloudMeshes, projPool, points, pPos, pCol, PMAX,
|
||
rain, snow, lightPool, flamePool, boatMesh,
|
||
blockMeshes: [], lastVersion: -1,
|
||
mobs: new Map(), players: new Map(),
|
||
theta: 0.30, phi: 0.26, dist: 16,
|
||
ptrs: new Map(), pinchD: 0,
|
||
lastTap: null, fireCache: null, fireAt: 0,
|
||
heroStep: 0, heroT: 0, face: 1, frame: 0, lastT: 0,
|
||
colCache: new Map(),
|
||
};
|
||
TDbindInput(canvas);
|
||
TDresize();
|
||
window.addEventListener('resize', TDresize);
|
||
}
|
||
|
||
function TDresize() {
|
||
if (!TD) return;
|
||
const w = window.innerWidth, h = window.innerHeight;
|
||
state.W = w;
|
||
state.H = h;
|
||
TD.renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2));
|
||
TD.renderer.setSize(w, h, false);
|
||
TD.camera.aspect = w / h;
|
||
TD.camera.updateProjectionMatrix();
|
||
}
|
||
|
||
// ---------- блоки ----------
|
||
function TDrebuildBlocks() {
|
||
for (const e of TD.blockMeshes) {
|
||
TD.scene.remove(e.mesh);
|
||
e.mesh.geometry.dispose();
|
||
e.mesh.material.dispose();
|
||
}
|
||
TD.blockMeshes = [];
|
||
const byType = new Map();
|
||
for (const b of state.blocks) {
|
||
if (b.dead) continue;
|
||
if (!BLOCKS[b.t]) continue;
|
||
if (!byType.has(b.t)) byType.set(b.t, []);
|
||
byType.get(b.t).push(b);
|
||
}
|
||
const boxGeo = new THREE.BoxGeometry(1, 1, 1);
|
||
const planeGeo = new THREE.PlaneGeometry(0.92, 0.92);
|
||
for (const [t, list] of byType) {
|
||
const fluid = TDisFluid(t);
|
||
const decor = !fluid && TDisDecor(t);
|
||
const mesh = new THREE.InstancedMesh(decor ? planeGeo : boxGeo, TDblockMat(t), list.length);
|
||
mesh.castShadow = !decor;
|
||
mesh.receiveShadow = true;
|
||
if (decor) mesh.material.side = THREE.DoubleSide;
|
||
const m = new THREE.Matrix4();
|
||
for (let i = 0; i < list.length; i++) {
|
||
const b = list[i];
|
||
if (fluid) {
|
||
m.makeScale(1, 0.8, 1);
|
||
m.setPosition(b.gx, -b.gy - 0.1, 0);
|
||
} else {
|
||
m.identity();
|
||
m.setPosition(b.gx, -b.gy, 0);
|
||
}
|
||
mesh.setMatrixAt(i, m);
|
||
}
|
||
mesh.instanceMatrix.needsUpdate = true;
|
||
mesh.userData.list = list;
|
||
TD.scene.add(mesh);
|
||
TD.blockMeshes.push({ mesh, type: t });
|
||
}
|
||
TD.lastVersion = state.blocksVersion || 0;
|
||
}
|
||
|
||
// ---------- pick ----------
|
||
const TDray = new THREE.Raycaster();
|
||
const TDndc = new THREE.Vector2();
|
||
const TDplane = new THREE.Plane(new THREE.Vector3(0, 0, 1), 0);
|
||
const TDhitP = new THREE.Vector3();
|
||
|
||
function TDpick(sx, sy) {
|
||
const r = state.canvas.getBoundingClientRect();
|
||
TDndc.x = ((sx - r.left) / r.width) * 2 - 1;
|
||
TDndc.y = -((sy - r.top) / r.height) * 2 + 1;
|
||
TDray.setFromCamera(TDndc, TD.camera);
|
||
const hits = TDray.intersectObjects(TD.blockMeshes.map(e => e.mesh), false);
|
||
if (hits.length) {
|
||
const h = hits[0];
|
||
const b = h.object.userData.list[h.instanceId];
|
||
if (b) return { wx: h.point.x * state.TILE, wy: -h.point.y * state.TILE, gx: b.gx, gy: b.gy };
|
||
}
|
||
if (TDray.ray.intersectPlane(TDplane, TDhitP)) {
|
||
return {
|
||
wx: TDhitP.x * state.TILE, wy: -TDhitP.y * state.TILE,
|
||
gx: Math.floor(TDhitP.x), gy: Math.floor(-TDhitP.y),
|
||
};
|
||
}
|
||
return null;
|
||
}
|
||
|
||
// ---------- ввод: drag = орбита, щипок/колесо = зум, тап = действие ----------
|
||
function TDbindInput(canvas) {
|
||
canvas.addEventListener('pointerdown', (e) => {
|
||
TD.ptrs.set(e.pointerId, { x: e.clientX, y: e.clientY, sx: e.clientX, sy: e.clientY, moved: false, t: performance.now() });
|
||
if (TD.ptrs.size === 2) {
|
||
const q = [...TD.ptrs.values()];
|
||
TD.pinchD = Math.hypot(q[0].x - q[1].x, q[0].y - q[1].y);
|
||
}
|
||
stopMining();
|
||
});
|
||
|
||
canvas.addEventListener('pointermove', (e) => {
|
||
const q = TD.ptrs.get(e.pointerId);
|
||
if (!q) return;
|
||
const dx = e.clientX - q.x, dy = e.clientY - q.y;
|
||
q.x = e.clientX; q.y = e.clientY;
|
||
if (Math.hypot(e.clientX - q.sx, e.clientY - q.sy) > 8) q.moved = true;
|
||
if (TD.ptrs.size === 2) {
|
||
const v = [...TD.ptrs.values()];
|
||
const d = Math.hypot(v[0].x - v[1].x, v[0].y - v[1].y);
|
||
if (TD.pinchD > 0 && d > 0) TD.dist = Math.min(32, Math.max(5, TD.dist * TD.pinchD / d));
|
||
TD.pinchD = d;
|
||
return;
|
||
}
|
||
if (q.moved) {
|
||
TD.theta -= dx * 0.005;
|
||
TD.phi = Math.min(1.35, Math.max(0.18, TD.phi + dy * 0.005));
|
||
}
|
||
});
|
||
|
||
const up = (e) => {
|
||
const q = TD.ptrs.get(e.pointerId);
|
||
TD.ptrs.delete(e.pointerId);
|
||
TD.pinchD = 0;
|
||
if (q && !q.moved && performance.now() - q.t < 600) {
|
||
const hit = TDpick(e.clientX, e.clientY);
|
||
if (hit) {
|
||
TD.lastTap = { gx: hit.gx, gy: hit.gy };
|
||
handleTap(hit.wx, hit.wy);
|
||
}
|
||
}
|
||
};
|
||
canvas.addEventListener('pointerup', up);
|
||
canvas.addEventListener('pointercancel', (e) => { TD.ptrs.delete(e.pointerId); TD.pinchD = 0; });
|
||
canvas.addEventListener('contextmenu', (e) => e.preventDefault());
|
||
canvas.addEventListener('wheel', (e) => {
|
||
e.preventDefault();
|
||
e.stopPropagation();
|
||
TD.dist = Math.min(32, Math.max(5, TD.dist * (1 + e.deltaY * 0.001)));
|
||
}, { passive: false, capture: true });
|
||
}
|
||
|
||
// ---------- сущности ----------
|
||
function TDmobMesh(m) {
|
||
let e = TD.mobs.get(m);
|
||
if (!e) {
|
||
const g = new THREE.Group();
|
||
const body = new THREE.Mesh(
|
||
new THREE.BoxGeometry(1, 1, 0.6),
|
||
new THREE.MeshLambertMaterial({ color: TD_MOB_COLORS[m.kind] || 0x2ecc71 })
|
||
);
|
||
body.castShadow = true;
|
||
g.add(body);
|
||
const eyeM = new THREE.MeshBasicMaterial({ color: 0x111111 });
|
||
const e1 = new THREE.Mesh(new THREE.BoxGeometry(0.12, 0.12, 0.05), eyeM);
|
||
e1.position.set(-0.15, 0.25, 0.31);
|
||
const e2 = e1.clone();
|
||
e2.position.x = 0.15;
|
||
g.add(e1, e2);
|
||
TD.scene.add(g);
|
||
e = { g, body };
|
||
TD.mobs.set(m, e);
|
||
}
|
||
return e;
|
||
}
|
||
|
||
function TDplayerEntry(id, p) {
|
||
let e = TD.players.get(id);
|
||
if (!e) {
|
||
const rig = TDbuildHeroRig();
|
||
const label = TDnameSprite(p.name);
|
||
label.position.y = 2.2;
|
||
rig.group.add(label);
|
||
TD.scene.add(rig.group);
|
||
e = { rig, label };
|
||
TD.players.set(id, e);
|
||
}
|
||
return e;
|
||
}
|
||
|
||
// ---------- кадр ----------
|
||
export function renderFrame3D(now) {
|
||
if (!TD) TDinit();
|
||
const player = state.player;
|
||
const TILE = state.TILE;
|
||
TD.frame++;
|
||
const dt = Math.min(0.05, Math.max(0.001, (now - (TD.lastT || now - 16)) / 1000));
|
||
TD.lastT = now;
|
||
|
||
if ((state.blocksVersion || 0) !== TD.lastVersion) TDrebuildBlocks();
|
||
|
||
const night = isNight();
|
||
const px = (player.x + (player.w || 24) / 2) / TILE;
|
||
const py = TDY(player.y + (player.h || 70) / 2);
|
||
|
||
// небо и свет
|
||
const sky = skyColor(night, getBiome(Math.floor(player.x / TILE)), state.weatherType, state.worldTime);
|
||
TD.scene.background.set(sky);
|
||
TD.scene.fog.color.copy(TD.scene.background);
|
||
TD.sun.intensity = night ? 0.14 : 1.5;
|
||
TD.hemi.intensity = night ? 0.32 : 0.9;
|
||
TD.amb.intensity = night ? 0.34 : 0.25;
|
||
if (state.lightningFlash > 0) TD.hemi.intensity += Math.min(2.2, state.lightningFlash * 2.4);
|
||
TD.backWall.position.set(px, py, -2.5);
|
||
TD.groundPlane.position.set(px, Math.round(TDY(player.y) - 40), 3);
|
||
TD.sun.position.set(px + 25, py + 40, 25);
|
||
TD.sun.target.position.set(px, py, 0);
|
||
TD.sun.target.updateMatrixWorld();
|
||
|
||
// камера-орбита вокруг игрока
|
||
const cp = Math.cos(TD.phi), sp = Math.sin(TD.phi);
|
||
const camY = py + TD.dist * sp;
|
||
TD.camera.position.set(
|
||
px + TD.dist * Math.sin(TD.theta) * cp,
|
||
Math.max(camY, py + 1.2),
|
||
TD.dist * Math.cos(TD.theta) * cp
|
||
);
|
||
TD.camera.lookAt(px, py + 0.3, 0);
|
||
|
||
// герой: ноги на ступнях коллайдера + анимация шага
|
||
TD.hero.group.position.set(px, TDY(player.y), 0);
|
||
TD.heroT += dt;
|
||
const moving = Math.abs(player.vx || 0) > 20 && player.onGround;
|
||
if (moving) TD.heroStep += dt * 11;
|
||
TD.hero.P.legs.rotation.z = moving ? Math.sin(TD.heroStep) * 0.34 : 0;
|
||
if (player.vx > 20) TD.face = 1;
|
||
else if (player.vx < -20) TD.face = -1;
|
||
const wantYaw = TD.face * 0.34;
|
||
TD.hero.group.rotation.y += (wantYaw - TD.hero.group.rotation.y) * Math.min(1, 9 * dt);
|
||
|
||
// мобы
|
||
const allMobs = state.isMultiplayer ? Array.from(state.serverMobs.values()) : state.mobs;
|
||
const seen = new Set();
|
||
for (const m of allMobs) {
|
||
if (m.dead) continue;
|
||
seen.add(m);
|
||
const e = TDmobMesh(m);
|
||
const w = (m.w || 30) / TILE, h = (m.h || 30) / TILE;
|
||
e.body.scale.set(w, h, 1);
|
||
e.g.position.set((m.x + (m.w || 30) / 2) / TILE, TDY(m.y + (m.h || 30) / 2), 0);
|
||
}
|
||
for (const [m, e] of TD.mobs) {
|
||
if (!seen.has(m)) {
|
||
TD.scene.remove(e.g);
|
||
TD.mobs.delete(m);
|
||
}
|
||
}
|
||
|
||
// другие игроки
|
||
const seenP = new Set();
|
||
if (state.otherPlayers) {
|
||
for (const [id, p] of state.otherPlayers) {
|
||
seenP.add(id);
|
||
const e = TDplayerEntry(id, p);
|
||
e.rig.group.position.set((p.x + 17) / TILE, TDY(p.y), 0);
|
||
}
|
||
}
|
||
for (const [id, e] of TD.players) {
|
||
if (!seenP.has(id)) {
|
||
TD.scene.remove(e.rig.group);
|
||
TD.players.delete(id);
|
||
}
|
||
}
|
||
|
||
// лодка
|
||
if (state.boat && state.boat.active) {
|
||
TD.boatMesh.visible = true;
|
||
TD.boatMesh.position.set(state.boat.x / TILE, TDY(state.boat.y), 0);
|
||
} else TD.boatMesh.visible = false;
|
||
|
||
// снаряды
|
||
const projs = state.projectiles || [];
|
||
for (let i = 0; i < TD.projPool.length; i++) {
|
||
const mesh = TD.projPool[i];
|
||
const pr = projs[i];
|
||
if (!pr) { mesh.visible = false; continue; }
|
||
mesh.visible = true;
|
||
mesh.material.color.set(pr.owner === 'mob' ? 0xc0392b : 0xf1c40f);
|
||
mesh.position.set(pr.x / TILE, TDY(pr.y), 0.35);
|
||
mesh.rotation.z = -Math.atan2(pr.vy, pr.vx);
|
||
}
|
||
|
||
// частицы
|
||
const parts = state.parts || [];
|
||
const n = Math.min(parts.length, TD.PMAX);
|
||
for (let i = 0; i < n; i++) {
|
||
const pt = parts[i];
|
||
TD.pPos[i * 3] = pt.x / TILE;
|
||
TD.pPos[i * 3 + 1] = TDY(pt.y);
|
||
TD.pPos[i * 3 + 2] = 0.3;
|
||
let cc = TD.colCache.get(pt.c);
|
||
if (!cc) { cc = new THREE.Color(pt.c || '#ffffff'); TD.colCache.set(pt.c, cc); }
|
||
TD.pCol[i * 3] = cc.r; TD.pCol[i * 3 + 1] = cc.g; TD.pCol[i * 3 + 2] = cc.b;
|
||
}
|
||
TD.points.geometry.setDrawRange(0, n);
|
||
TD.points.geometry.attributes.position.needsUpdate = true;
|
||
TD.points.geometry.attributes.color.needsUpdate = true;
|
||
|
||
// облака
|
||
const clouds = state.clouds || [];
|
||
for (let i = 0; i < TD.cloudMeshes.length; i++) {
|
||
const cm = TD.cloudMeshes[i];
|
||
const c = clouds.length ? clouds[i % clouds.length] : null;
|
||
if (!c) { cm.visible = false; continue; }
|
||
cm.visible = true;
|
||
cm.scale.set((c.w || 120) / TILE, 1, 1);
|
||
cm.position.set(c.x / TILE, TDY(c.y), -8);
|
||
}
|
||
|
||
// огни (костры/печи/факелы/светящиеся) — кеш раз в 20 кадров
|
||
if (TD.frame % 20 === 0 || !TD.fireCache) {
|
||
const found = [];
|
||
for (const b of state.blocks) {
|
||
if (b.dead) continue;
|
||
const def = BLOCKS[b.t];
|
||
if (!def) continue;
|
||
const lit = def.lightRadius ||
|
||
b.t === 'campfire' ||
|
||
(b.t === 'furnace' && state.activeFurnaces && state.activeFurnaces.has(b.gx + ',' + b.gy));
|
||
if (!lit) continue;
|
||
const dx = b.gx - px, dy = -b.gy - py;
|
||
found.push({ t: b.t, gx: b.gx, gy: b.gy, d: dx * dx + dy * dy });
|
||
}
|
||
found.sort((a, b) => a.d - b.d);
|
||
TD.fireCache = found.slice(0, 8);
|
||
}
|
||
for (const L of TD.lightPool) L.intensity = 0;
|
||
for (const f of TD.flamePool) f.visible = false;
|
||
let li = 0, fi = 0;
|
||
for (const src of (TD.fireCache || [])) {
|
||
if (li < TD.lightPool.length) {
|
||
const L = TD.lightPool[li++];
|
||
L.position.set(src.gx, -src.gy, 1.6);
|
||
L.intensity = 1.5 + Math.sin(now / 130 + src.gx) * 0.35;
|
||
}
|
||
if ((src.t === 'campfire' || src.t === 'furnace') && fi < TD.flamePool.length) {
|
||
const f = TD.flamePool[fi++];
|
||
f.visible = true;
|
||
f.position.set(src.gx, -src.gy + 0.72 + Math.sin(now / 90 + src.gy) * 0.06, 0.2);
|
||
const s = 0.9 + Math.sin(now / 70 + src.gx * 2) * 0.18;
|
||
f.scale.set(s, s * (1 + Math.sin(now / 55) * 0.12), s);
|
||
}
|
||
}
|
||
|
||
// погода
|
||
if (state.isRaining) {
|
||
TD.rain.pts.visible = true;
|
||
for (let i = 0; i < TD.rain.n; i++) {
|
||
let y = TD.rain.pos[i * 3 + 1] - dt * 28;
|
||
let x = TD.rain.pos[i * 3];
|
||
if (y < py - 14) { y = py + 14; x = px + (Math.random() - 0.5) * 44; }
|
||
TD.rain.pos[i * 3] = x;
|
||
TD.rain.pos[i * 3 + 1] = y;
|
||
TD.rain.pos[i * 3 + 2] = 4;
|
||
}
|
||
TD.rain.pts.geometry.attributes.position.needsUpdate = true;
|
||
} else TD.rain.pts.visible = false;
|
||
|
||
if (state.weatherType === 'snow') {
|
||
TD.snow.pts.visible = true;
|
||
for (let i = 0; i < TD.snow.n; i++) {
|
||
let y = TD.snow.pos[i * 3 + 1] - dt * 2.2;
|
||
let x = TD.snow.pos[i * 3] + Math.sin(now / 900 + i) * dt * 1.5;
|
||
if (y < py - 14) { y = py + 14; x = px + (Math.random() - 0.5) * 44; }
|
||
TD.snow.pos[i * 3] = x;
|
||
TD.snow.pos[i * 3 + 1] = y;
|
||
TD.snow.pos[i * 3 + 2] = 4;
|
||
}
|
||
TD.snow.pts.geometry.attributes.position.needsUpdate = true;
|
||
} else TD.snow.pts.visible = false;
|
||
|
||
// прогресс добычи
|
||
const mg = state.mining;
|
||
if (mg && mg.gx !== null && mg.hardness > 0) {
|
||
TD.crack.visible = true;
|
||
TD.crack.position.set(mg.gx, -mg.gy, 0);
|
||
TD.crack.material.opacity = Math.min(0.55, (mg.progress / mg.hardness) * 0.55);
|
||
} else TD.crack.visible = false;
|
||
|
||
// ghost постройки
|
||
if (mode() === 'build' && TD.lastTap && !state.craftOpen && player.hp > 0) {
|
||
TD.ghost.visible = true;
|
||
TD.ghost.position.set(TD.lastTap.gx, -TD.lastTap.gy, 0);
|
||
} else TD.ghost.visible = false;
|
||
|
||
// окно могло сменить размер
|
||
if (state.W !== window.innerWidth || state.H !== window.innerHeight) TDresize();
|
||
TD.camera.aspect = window.innerWidth / window.innerHeight;
|
||
TD.camera.updateProjectionMatrix();
|
||
|
||
TD.renderer.render(TD.scene, TD.camera);
|
||
}
|