Spaces:
Running
Running
| // Oyun çekirdeği: fizik, seviye kurulumu, çarpışma, park kontrolü. DOM'a dokunmaz; | |
| // tarayıcıda <script> ile, Node'da (test/bot.js) require ile yüklenir. Sürüş sabitleri game.py'den | |
| // alındı; araç tipleri ve seviyeler yalnız web sürümünde var. | |
| // Araç tipleri: L boy, W en, wb dingil mesafesi (dönüş yarıçapını belirler) | |
| const VEHICLES = { | |
| hatchback: { L: 70, W: 38, wb: 46 }, | |
| sedan: { L: 82, W: 40, wb: 52 }, | |
| kamyonet: { L: 88, W: 42, wb: 56 }, | |
| van: { L: 86, W: 44, wb: 56 }, | |
| tir: { L: 200, W: 50, wb: 120 }, | |
| }; | |
| const CEP_TIPLERI = ["hatchback", "sedan", "kamyonet", "van"]; // cebe sığanlar | |
| const COLORS = ["#e2483d", "#2f6fb2", "#e9e2d0", "#8fc7a3", "#b86b2c", "#9b7fd1", "#f28fb0", "#4fb3bf", "#6f7686", "#ffc93c"]; | |
| const CREEP = 18; // px/sn, ileri/geri sonrası araç bu hızla süzülür | |
| const SPEED_STEP = 8, MIN_SPEED = 6, MAX_SPEED = 45; // "hızlı"/"yavaş" adımı ve sınırları | |
| const BRAKE = 160; // px/sn² | |
| const MAX_STEER = (35 * Math.PI) / 180, STEER_RATE = (110 * Math.PI) / 180; | |
| const PARK_POINTS = 500, TIME_BONUS = 5, CRASH_PENALTY = 100; | |
| // yoldan geçen araçlar: önlerinde oyuncu varsa yavaşlayıp dururlar, yol açılınca düz devam ederler | |
| const TRAFFIC = { accel: 60, decel: 200, minGap: 4, spawnMin: 5, spawnMax: 11, perLane: 2, cruise: [55, 80], honkAfter: 1.5 }; | |
| // Oyun alanı: masaüstünde yatay, telefonda dikey. rows: 2 olan dünyada yolun altında karşı kaldırım ve | |
| // ikinci bir park sırası olur (dikey ekranın alt yarısı boş kalmasın) | |
| const WORLDS = { | |
| wide: { W: 900, H: 600, CURB: 70, nSpots: 10, rows: 1 }, | |
| tall: { W: 560, H: 720, CURB: 70, nSpots: 6, rows: 2 }, | |
| }; | |
| // kind: "dik" cebe burnu ya da arkası önde | "geri" cebe geri geri, burun yola bakar | "paralel" kaldırım boyu | |
| // Her seviyenin komutlarla çözülebildiği test/bot.js ile sınanır. | |
| const LEVELS = [ | |
| { name: "Çırak", kind: "dik", spotW: 92, spotD: 115, time: 90, points: 500, hint: "Yeşil park yerine burnunu sok" }, | |
| { name: "Kalfa", kind: "dik", spotW: 80, spotD: 115, time: 85, points: 600, hint: "Park yerleri daraldı" }, | |
| { name: "Geri Geri", kind: "geri", spotW: 88, spotD: 115, time: 100, points: 700, hint: "Park yerine geri geri gir, burun yola baksın" }, | |
| { name: "Usta", kind: "dik", spotW: 72, spotD: 115, time: 80, points: 800, hint: "Milim milim" }, | |
| { name: "Paralel", kind: "paralel", slotL: 110, gapL: 150, spotD: 62, time: 110, points: 900, hint: "Kaldırıma paralel park et" }, | |
| { name: "Değnekçi", kind: "geri", spotW: 76, spotD: 115, time: 90, points: 1000, hint: "Dar park yerine geri geri" }, | |
| ]; | |
| function corners(x, y, ang, length, width) { | |
| const c = Math.cos(ang), s = Math.sin(ang), hl = length / 2, hw = width / 2; | |
| return [[hl, hw], [hl, -hw], [-hl, -hw], [-hl, hw]].map(([dx, dy]) => [x + c * dx - s * dy, y + s * dx + c * dy]); | |
| } | |
| // İki dışbükey çokgen kesişiyor mu (ayırıcı eksen teoremi) | |
| function overlap(p, q) { | |
| for (const poly of [p, q]) { | |
| for (let i = 0; i < poly.length; i++) { | |
| const [x1, y1] = poly[i], [x2, y2] = poly[(i + 1) % poly.length]; | |
| const nx = y1 - y2, ny = x2 - x1; | |
| const a = p.map(([x, y]) => nx * x + ny * y), b = q.map(([x, y]) => nx * x + ny * y); | |
| if (Math.max(...a) < Math.min(...b) || Math.max(...b) < Math.min(...a)) return false; | |
| } | |
| } | |
| return true; | |
| } | |
| class Car { | |
| constructor(x, y, ang, type = "sedan", color = COLORS[0]) { | |
| Object.assign(this, { x, y, ang, type, color }, VEHICLES[type]); | |
| this.speed = 0; // hız büyüklüğü | |
| this.gear = 1; // 1 ileri, -1 geri | |
| this.steer = 0; | |
| this.steerTarget = 0; | |
| this.lastDir = 1; // "kır" için son yön (1 sağ, -1 sol) | |
| this.stopped = true; // ileri/geri denene kadar bekler | |
| } | |
| poly() { | |
| return corners(this.x, this.y, this.ang, this.L, this.W); | |
| } | |
| command(cmd) { | |
| if (cmd === "hızlı" || cmd === "yavaş") { | |
| if (this.stopped) return; // duran aracı yalnız ileri/geri kaldırır | |
| const step = cmd === "hızlı" ? SPEED_STEP : -SPEED_STEP; | |
| this.speed = Math.min(MAX_SPEED, Math.max(MIN_SPEED, this.speed + step)); | |
| } else if (cmd === "dur") { | |
| this.stopped = true; | |
| } else if (cmd === "ileri" || cmd === "geri") { | |
| const g = cmd === "ileri" ? 1 : -1; | |
| if (g !== this.gear || this.stopped) this.speed = CREEP; // vites değişince/dururken yavaştan başla | |
| this.gear = g; | |
| this.stopped = false; | |
| } else if (cmd === "sağa" || cmd === "sola") { | |
| this.lastDir = cmd === "sağa" ? 1 : -1; | |
| this.steerTarget = this.lastDir * MAX_STEER; | |
| } else if (cmd === "kır") { | |
| this.steerTarget = this.lastDir * MAX_STEER; | |
| } else if (cmd === "topla") { | |
| this.steerTarget = 0; | |
| } | |
| } | |
| update(dt) { | |
| const d = this.steerTarget - this.steer, r = STEER_RATE * dt; | |
| this.steer += Math.max(-r, Math.min(r, d)); | |
| if (this.stopped) this.speed = Math.max(0, this.speed - BRAKE * dt); | |
| const v = this.gear * this.speed; | |
| this.x += v * Math.cos(this.ang) * dt; | |
| this.y += v * Math.sin(this.ang) * dt; | |
| this.ang += (v / this.wb) * Math.tan(this.steer) * dt; | |
| } | |
| } | |
| function pick(rng, arr) { | |
| return arr[Math.floor(rng() * arr.length)]; | |
| } | |
| class Sim { | |
| // rng: test için tohumlanabilir rastgele sayı üreteci | |
| // opts.traffic: false ile yoldan geçen araçlar kapatılır (bot geometriyi trafiksiz sınar) | |
| // opts.avoid: [x0, y0, x1, y1] dikdörtgenleri (ekran butonları); hedef bunların altına düşmez | |
| // opts.row: "top" | "bottom" hedef sırasını zorlar (test için) | |
| constructor(worldName, levelIndex, rng = Math.random, opts = {}) { | |
| this.opts = opts; | |
| this.world = typeof worldName === "string" ? WORLDS[worldName] : worldName; // ad ya da {W, H, ...} | |
| this.level = LEVELS[levelIndex]; | |
| this.rng = rng; | |
| this.timeLeft = this.level.time; | |
| this.crashCool = 0; | |
| this.done = false; | |
| this.trafficOn = opts.traffic !== false; | |
| this.traffic = []; | |
| this.setup(); | |
| } | |
| setup() { | |
| const { W, H, CURB } = this.world, two = this.world.rows === 2, rowBottom = CURB + this.level.spotD; | |
| this.bottomCurb = two ? H - CURB : H; // alt kaldırımın başladığı y | |
| if (this.level.kind === "paralel") this.setupParalel(); | |
| else this.setupDik(); | |
| let startY; | |
| if (two) { | |
| // iki sıra: oyuncu üst sıranın altından başlar, iki yönlü şeritler yolun ortasında | |
| startY = this.level.kind === "paralel" ? rowBottom + 85 : rowBottom + 150; | |
| const mid = (startY + this.bottomCurb - this.level.spotD) / 2; | |
| this.lanes = this.level.kind === "paralel" ? [{ y: Math.max(startY + 62, mid), dir: 1 }] : [{ y: mid - 30, dir: 1 }, { y: mid + 30, dir: -1 }]; | |
| } else { | |
| // yolun sol alt kenarında park etmiş tır (sağ alt köşe ekran butonlarına ayrıldı); | |
| // oyuncu hep üstünden geçer, çizimde önde kalır | |
| const t = VEHICLES.tir; | |
| this.parked.push(this.vehicle("tir", t.L / 2 + 30, H - t.W / 2 - 8, Math.PI)); | |
| startY = this.level.kind === "paralel" ? rowBottom + 85 : rowBottom + 240; | |
| // şeritler: cep sırası ile oyuncunun başladığı yer arasında iki yön; paralelde oyuncunun bir altı | |
| this.lanes = this.level.kind === "paralel" ? [{ y: startY + 62, dir: 1 }] : [{ y: rowBottom + 110, dir: 1 }, { y: rowBottom + 170, dir: -1 }]; | |
| } | |
| this.car = new Car(60, startY, 0, pick(this.rng, CEP_TIPLERI), pick(this.rng, COLORS)); // sağa bakarak başlar | |
| for (const l of this.lanes) l.next = 1.5 + this.rng() * 4; // ilk araç biraz gecikmeli gelsin | |
| } | |
| spawnTraffic(dt) { | |
| const { W } = this.world; | |
| for (const l of this.lanes) { | |
| l.next -= dt; | |
| if (l.next > 0) continue; | |
| l.next = TRAFFIC.spawnMin + this.rng() * (TRAFFIC.spawnMax - TRAFFIC.spawnMin); | |
| if (this.traffic.filter((t) => t.lane === l).length >= TRAFFIC.perLane) continue; | |
| const type = pick(this.rng, CEP_TIPLERI), { L } = VEHICLES[type]; | |
| const x = l.dir > 0 ? -L / 2 - 10 : W + L / 2 + 10; | |
| const v = this.vehicle(type, x, l.y, l.dir > 0 ? 0 : Math.PI); | |
| // giriş ağzı doluysa (oyuncu ya da başka araç) bu sefer atla | |
| const probe = corners(x, l.y, v.ang, L + 120, v.W + 10); | |
| if (overlap(probe, this.car.poly()) || this.traffic.some((t) => overlap(probe, t.poly))) continue; | |
| const [lo, hi] = TRAFFIC.cruise, cruise = lo + this.rng() * (hi - lo); | |
| this.traffic.push(Object.assign(v, { lane: l, dir: l.dir, speed: cruise, cruise, braking: false, waited: 0, honked: false })); | |
| } | |
| } | |
| // Trafiği ilerletir; oyuncuya çarpma olursa (oyuncu önüne kırdıysa) true döner | |
| moveTraffic(dt, ev) { | |
| const { W } = this.world, player = this.car.poly(); | |
| let hit = false; | |
| for (const t of this.traffic) { | |
| // önündeki kutuda oyuncu ya da başka araç varsa dur | |
| const look = 20 + t.speed * 0.8, cx = t.x + t.dir * (t.L / 2 + TRAFFIC.minGap + look / 2); | |
| const ahead = corners(cx, t.y, t.ang, look, t.W + 14); | |
| const blocked = overlap(ahead, player) || this.traffic.some((o) => o !== t && overlap(ahead, o.poly)); | |
| t.braking = blocked; | |
| t.speed = blocked ? Math.max(0, t.speed - TRAFFIC.decel * dt) : Math.min(t.cruise, t.speed + TRAFFIC.accel * dt); | |
| if (blocked && t.speed === 0) { | |
| t.waited += dt; | |
| if (t.waited > TRAFFIC.honkAfter && !t.honked && overlap(ahead, player)) { | |
| t.honked = true; | |
| ev.push({ type: "honk" }); | |
| } | |
| } else if (!blocked) { | |
| t.waited = 0; | |
| t.honked = false; | |
| } | |
| const nx = t.x + t.dir * t.speed * dt, poly = corners(nx, t.y, t.ang, t.L, t.W); | |
| if (overlap(poly, player)) { | |
| t.speed = 0; // durmasına fırsat vermeden önüne kırıldı | |
| hit = true; | |
| continue; | |
| } | |
| t.x = nx; | |
| t.poly = poly; | |
| } | |
| this.traffic = this.traffic.filter((t) => t.x > -t.L - 40 && t.x < W + t.L + 40); | |
| return hit; | |
| } | |
| // Hedef: üst sırada uçlar hariç herhangi bir cep; iki sıralı dünyada yarı yarıya alt sıra da olabilir, | |
| // ama ekran butonlarının (opts.avoid) altında kalan alt cepler seçilmez | |
| pickTarget() { | |
| const ok = (sp, row) => { | |
| if (row[0] === sp || row[row.length - 1] === sp) return false; | |
| return !(this.opts.avoid || []).some(([x0, y0, x1, y1]) => sp.x < x1 && sp.x + sp.w > x0 && sp.y < y1 && sp.y + sp.h > y0); | |
| }; | |
| const rows = ["top", "bottom"].map((r) => this.spots.filter((sp) => sp.row === r)); | |
| const cands = rows.map((row) => row.filter((sp) => ok(sp, row))); | |
| let row = this.opts.row === "bottom" ? 1 : this.opts.row === "top" ? 0 : cands[1].length && this.rng() < 0.5 ? 1 : 0; | |
| if (!cands[row].length) row = 0; | |
| return this.spots.indexOf(pick(this.rng, cands[row])); | |
| } | |
| // Park etmiş araçlar biraz yamuk durur: yana kaymış, içeri/dışarı taşmış, hafif açılı | |
| parkIn(sp) { | |
| const r = this.rng, top = sp.row === "top"; | |
| const nose = r() < 0.75 ? 1 : -1; // çoğu burnu kaldırıma dönük, bazısı geri geri girmiş | |
| const ang = (top ? Math.PI / 2 : -Math.PI / 2) * nose + (r() - 0.5) * 0.2; | |
| const cx = sp.x + sp.w / 2 + (r() - 0.5) * 14; | |
| const cy = sp.y + sp.h / 2 + (top ? 1 : -1) * (r() - 0.35) * 14; | |
| return this.vehicle(pick(r, CEP_TIPLERI), cx, cy, ang); | |
| } | |
| setupDik() { | |
| const { W, CURB } = this.world, { spotW, spotD } = this.level; | |
| const nSpots = Math.min(this.world.nSpots, Math.floor((W - 20) / spotW)); | |
| const x0 = (W - nSpots * spotW) / 2; | |
| this.spots = Array.from({ length: nSpots }, (_, i) => ({ x: x0 + i * spotW, y: CURB, w: spotW, h: spotD, row: "top" })); | |
| if (this.world.rows === 2) { | |
| for (let i = 0; i < nSpots; i++) this.spots.push({ x: x0 + i * spotW, y: this.bottomCurb - spotD, w: spotW, h: spotD, row: "bottom" }); | |
| } | |
| this.target = this.pickTarget(); | |
| this.parked = []; | |
| this.spots.forEach((sp, i) => { | |
| if (i !== this.target) this.parked.push(this.parkIn(sp)); | |
| }); | |
| } | |
| // kaldırım boyunca dizili araçlar, aralarında bir boşluk; iki sıralı dünyada alt kaldırım da doludur | |
| setupParalel() { | |
| const { W, CURB } = this.world, { slotL, gapL, spotD } = this.level; | |
| const n = 1 + Math.floor((W - 40 - gapL) / slotL); | |
| const x0 = (W - (n - 1) * slotL - gapL) / 2; | |
| const ti = 1 + Math.floor(this.rng() * (n - 2)); | |
| this.spots = []; | |
| this.parked = []; | |
| const r = this.rng; | |
| for (let i = 0, x = x0; i < n; i++) { | |
| const w = i === ti ? gapL : slotL; | |
| this.spots.push({ x, y: CURB, w, h: spotD, row: "top" }); | |
| if (i !== ti) { | |
| const cx = x + w / 2 + (r() - 0.5) * 12, cy = CURB + spotD / 2 + (r() - 0.3) * 6; | |
| this.parked.push(this.vehicle(pick(r, CEP_TIPLERI), cx, cy, (r() - 0.5) * 0.1 + (r() < 0.3 ? Math.PI : 0))); | |
| } | |
| x += w; | |
| } | |
| this.target = ti; | |
| if (this.world.rows === 2) { | |
| // alt kaldırım: arka arkaya park etmiş, aralarında rastgele boşluklar | |
| for (let x = 20 + r() * 30; x + 90 < W - 10; x += 100 + r() * 40) { | |
| if (r() < 0.2) continue; | |
| const cy = this.bottomCurb - spotD / 2 - (r() - 0.3) * 6; | |
| this.parked.push(this.vehicle(pick(r, CEP_TIPLERI), x + 45, cy, Math.PI + (r() - 0.5) * 0.1 + (r() < 0.3 ? Math.PI : 0))); | |
| } | |
| } | |
| } | |
| vehicle(type, x, y, ang) { | |
| const { L, W, wb } = VEHICLES[type]; | |
| return { type, x, y, ang, L, W, wb, color: pick(this.rng, COLORS), poly: corners(x, y, ang, L, W) }; | |
| } | |
| collides(poly) { | |
| const { W, H, CURB } = this.world; | |
| if (poly.some(([x, y]) => x < 0 || x > W || y < CURB || y > this.bottomCurb)) return true; | |
| return this.parked.some((p) => overlap(poly, p.poly)) || this.traffic.some((t) => overlap(poly, t.poly)); | |
| } | |
| crash(ev, traffic) { | |
| if (this.crashCool > 0) return; | |
| this.crashCool = 1; | |
| ev.push({ type: "crash", points: -CRASH_PENALTY, traffic }); | |
| } | |
| isParked() { | |
| const s = this.spots[this.target], c = this.car; | |
| const inside = c.poly().every(([x, y]) => x >= s.x && x <= s.x + s.w && y >= s.y && y <= s.y + s.h); | |
| const tol = Math.cos((12 * Math.PI) / 180), kind = this.level.kind; | |
| const out = s.row === "bottom" ? -1 : 1; // geri parkta burun yola: üst sırada aşağı, alt sırada yukarı | |
| const straight = kind === "paralel" ? Math.abs(Math.cos(c.ang)) > tol : kind === "geri" ? out * Math.sin(c.ang) > tol : Math.abs(Math.sin(c.ang)) > tol; | |
| return inside && straight && c.stopped && c.speed < 1; | |
| } | |
| // dt saniye ilerletir; olayları döndürür: {type: "crash"} | {type: "park", points} | {type: "timeout"} | |
| step(dt) { | |
| if (this.done) return []; | |
| const ev = []; | |
| this.timeLeft = Math.max(0, this.timeLeft - dt); | |
| if (this.timeLeft <= 0) { | |
| this.done = true; | |
| return [{ type: "timeout" }]; | |
| } | |
| const c = this.car, prev = [c.x, c.y, c.ang]; | |
| this.crashCool -= dt; | |
| if (this.trafficOn) { | |
| this.spawnTraffic(dt); | |
| if (this.moveTraffic(dt, ev)) { | |
| c.speed = 0; | |
| c.stopped = true; | |
| this.crash(ev, true); | |
| } | |
| } | |
| c.update(dt); | |
| if (this.collides(c.poly())) { | |
| const poly = c.poly(), traffic = this.traffic.some((t) => overlap(poly, t.poly)); | |
| [c.x, c.y, c.ang] = prev; | |
| // biraz geri it ve durdur | |
| const back = -c.gear * 6; | |
| c.x += back * Math.cos(c.ang); | |
| c.y += back * Math.sin(c.ang); | |
| if (this.collides(c.poly())) [c.x, c.y, c.ang] = prev; | |
| c.speed = 0; | |
| c.stopped = true; | |
| this.crash(ev, traffic); | |
| } | |
| if (this.isParked()) { | |
| this.done = true; | |
| ev.push({ type: "park", points: (this.level.points || PARK_POINTS) + Math.floor(this.timeLeft) * TIME_BONUS }); | |
| } | |
| return ev; | |
| } | |
| } | |
| if (typeof module !== "undefined") { | |
| module.exports = { Sim, Car, LEVELS, WORLDS, VEHICLES, COLORS, MAX_STEER, corners, overlap }; | |
| } | |