tom/METH_Transcendence
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Game

Browse Source 
- Starting solo game
This commit is contained in:
Kum1ta
2024-08-28 17:30:46 +02:00
parent f2414f56a8
commit d28f1a3c26
12 changed files with 1151 additions and 852 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
site/real_game/class/SoloGame.js
View File

@ -6,18 +6,23 @@
/* By: edbernar <edbernar@student.42angouleme. +#+ +:+ +#+ */ /* By: edbernar <edbernar@student.42angouleme. +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/28 12:07:39 by edbernar #+# #+# */ /* Created: 2024/08/28 12:07:39 by edbernar #+# #+# */
/* Updated: 2024/08/28 14:07:55 by edbernar ### ########.fr */ /* Updated: 2024/08/28 16:48:12 by edbernar ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
import * as THREE from 'three'; import * as THREE from 'three';
import { Map } from './soloClass/Map.js' import { Map } from './soloClass/Map.js'
import { Players } from './soloClass/Players.js'
import { Ball } from './soloClass/Ball.js'
import { stats } from './MultiGame.js'; import { stats } from './MultiGame.js';
import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls.js';
let scene = null; let scene = null;
let renderer = null; let renderer = null;
let camera = null; let camera = null;
let map = null;
let controls = null;
class SoloGame class SoloGame
{ {
@ -25,21 +30,25 @@ class SoloGame
{ {
scene = new THREE.Scene(); scene = new THREE.Scene();
renderer = new THREE.WebGLRenderer({antialias: true}); renderer = new THREE.WebGLRenderer({antialias: true});
map = new Map(scene); renderer.shadowMap.enabled = true;
camera = new THREE.PerspectiveCamera(70, window.innerWidth / window.innerWidth); renderer.shadowMap.type = THREE.PCFSoftShadowMap;
Map.create(scene);
camera = new THREE.PerspectiveCamera(70, window.innerWidth / window.innerHeight);
camera.rotation.x = -Math.PI / 2; camera.rotation.x = -Math.PI / 2;
renderer.setSize(window.innerWidth, window.innerWidth); renderer.setSize(window.innerWidth, window.innerHeight);
scene.background = new THREE.Color(0xaaaaaa); scene.background = new THREE.Color(0x252525);
document.body.appendChild(renderer.domElement); document.body.appendChild(renderer.domElement);
scene.add(new THREE.AmbientLight(0xffffff, 1)); Players.create(scene);
Ball.create(scene);
controls = new OrbitControls(camera, renderer.domElement);
camera.position.set(0, 11, 0);
renderer.setAnimationLoop(loop) renderer.setAnimationLoop(loop)
} }
static dispose() static dispose()
{ {
if (map) Map.dispose();
map.dispose();
map = null;
if (renderer) if (renderer)
renderer.dispose(); renderer.dispose();
renderer = null; renderer = null;
@ -60,9 +69,13 @@ class SoloGame
} }
}; };
function loop() function loop()
{ {
stats.begin(); stats.begin();
controls.update();
Players.update();
Ball.update();
renderer.render(scene, camera); renderer.render(scene, camera);
stats.end(); stats.end();
} }

105
site/real_game/class/soloClass/Ball.js Normal file
View File

@ -0,0 +1,105 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Ball.js :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: edbernar <edbernar@student.42angouleme. +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/28 15:58:03 by edbernar #+# #+# */
/* Updated: 2024/08/28 17:30:09 by edbernar ### ########.fr */
/* */
/* ************************************************************************** */
import * as THREE from 'three';
import { wallTop, wallBottom } from './Map.js';
let ball = null;
let speed = 0.3;
// max 0.3 (sinon ca sort);
let dir = -1;
class Ball
{
static create(scene)
{
ball = createBall();
scene.add(ball);
ball.rotateY(0.3);
}
static dispose()
{
ball = null;
}
static update()
{
moveForward(ball, speed, false);
bounceWallTop();
bounceWallTBottom();
}
}
function moveForward(object, speed, bounceTop)
{
const direction = new THREE.Vector3(0, 0, dir);
direction.applyQuaternion(object.quaternion);
object.position.add(direction.multiplyScalar(speed));
}
function createBall()
{
const geometry = new THREE.SphereGeometry(0.3);
const material = new THREE.MeshPhysicalMaterial({color: 0xffffff});
const mesh = new THREE.Mesh(geometry, material);
mesh.position.y += 0.3;
mesh.position.set (0, mesh.position.y, 0);
return (mesh);
}
function bounceWallTop()
{
const origin = new THREE.Vector3(ball.position.x, ball.position.y, ball.position.z);
const direction = new THREE.Vector3(ball.position.x, ball.position.y, ball.position.z - 1);
direction.normalize();
const raycaster = new THREE.Raycaster(origin, direction);
const objects = [ wallTop ];
const intersects = raycaster.intersectObjects(objects);
if (intersects.length > 0)
{
console.log("Distance du rayon à l'objet : ", intersects[0].distance);
if (intersects[0].distance <= 0.5)
{
ball.rotation.y = Math.PI - ball.rotation.y
}
}
}
function bounceWallTBottom()
{
const origin = new THREE.Vector3(ball.position.x, ball.position.y, ball.position.z);
const direction = new THREE.Vector3(ball.position.x, ball.position.y, ball.position.z + 1);
direction.normalize();
const raycaster = new THREE.Raycaster(origin, direction);
const objects = [ wallBottom ];
const intersects = raycaster.intersectObjects(objects);
if (intersects.length > 0)
{
console.log("Distance du rayon à l'objet : ", intersects[0].distance);
if (intersects[0].distance <= 0.5)
{
ball.rotation.y = Math.PI - ball.rotation.y;
}
}
}
export { Ball };

48
site/real_game/class/soloClass/Map.js
View File

@ -6,32 +6,66 @@
/* By: edbernar <edbernar@student.42angouleme. +#+ +:+ +#+ */ /* By: edbernar <edbernar@student.42angouleme. +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/28 12:23:48 by edbernar #+# #+# */ /* Created: 2024/08/28 12:23:48 by edbernar #+# #+# */
/* Updated: 2024/08/28 14:01:24 by edbernar ### ########.fr */ /* Updated: 2024/08/28 17:01:17 by edbernar ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
import * as THREE from 'three'; import * as THREE from 'three';
const width = 25;
const height = 12.5;
let spotLight = null;
let wallTop = null;
let wallBottom = null;
class Map class Map
{ {
constructor(scene) static create(scene)
{ {
createGround(scene); createGround(scene);
wallBottom = createWall(false);
wallTop = createWall(true);
spotLight = new THREE.SpotLight({color: 0xffffff});
spotLight.castShadow = true;
spotLight.position.y = 10;
spotLight.intensity = 200;
scene.add(spotLight);
scene.add(wallTop);
scene.add(wallBottom);
scene.add(new THREE.AmbientLight(0xffffff, 0.5));
} }
dispose() static dispose()
{ {
if (spotLight)
spotLight.dispose();
spotLight = null;
} }
} }
function createGround(scene) function createGround(scene)
{ {
const geometry = new THREE.PlaneGeometry(window.innerWidth / 100, window.innerHeight / 100); const geometry = new THREE.PlaneGeometry(width, height);
const material = new THREE.MeshPhysicalMaterial(); const material = new THREE.MeshPhysicalMaterial({color: 0x222222});
const mesh = new THREE.Mesh(geometry, material); const mesh = new THREE.Mesh(geometry, material);
mesh.rotateX(-Math.PI / 2);
mesh.position.set(0, 0, 0);
scene.add(mesh); scene.add(mesh);
} }
export { Map }; function createWall(onTop)
{
const geometry = new THREE.BoxGeometry(width, 0.7, 0.2);
const material = new THREE.MeshPhysicalMaterial({color: 0x333333});
const mesh = new THREE.Mesh(geometry, material);
if (onTop)
mesh.position.z = -6.15;
else
mesh.position.z = 6.15;
mesh.position.y += 0.35;
return (mesh);
}
export { Map, wallBottom, wallTop };

95
site/real_game/class/soloClass/Players.js Normal file
View File

@ -0,0 +1,95 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* Players.js :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: edbernar <edbernar@student.42angouleme. +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/28 15:12:25 by edbernar #+# #+# */
/* Updated: 2024/08/28 16:29:28 by edbernar ### ########.fr */
/* */
/* ************************************************************************** */
import * as THREE from 'three';
const speed = 0.25;
let player1 = null;
let player2 = null;
let pressedButton = [];
class Players
{
static create(scene)
{
player1 = newBarPlayer(1);
player2 = newBarPlayer(2);
scene.add(player1);
scene.add(player2);
document.addEventListener('keydown', addKeyInArr);
document.addEventListener('keyup', remKeyInArr);
}
static dispose()
{
document.removeEventListener('keydown', addKeyInArr);
document.removeEventListener('keyup', remKeyInArr);
player1 = null;
player2 = null;
}
static update()
{
let i = 0;
while (i < pressedButton.length)
{
if (pressedButton[i] == 'w' && player1.position.z > -5.05)
player1.position.z -= speed;
else if (pressedButton[i] == 's' && player1.position.z < 5.05)
player1.position.z += speed;
else if (pressedButton[i] == 'ArrowUp' && player2.position.z > -5.05)
player2.position.z -= speed;
else if (pressedButton[i] == 'ArrowDown' && player2.position.z < 5.05)
player2.position.z += speed;
i++;
}
}
}
function newBarPlayer(nbPlayer)
{
const geometry = new THREE.BoxGeometry(0.1, 0.2, 2);
const material = new THREE.MeshPhysicalMaterial({color: 0xffffff});
const mesh = new THREE.Mesh(geometry, material);
if (nbPlayer == 1)
mesh.position.set(-12, 0.2, 0);
else
mesh.position.set(12, 0.2, 0);
return (mesh);
}
function addKeyInArr(e)
{
let i;
i = 0;
while (i < pressedButton.length && e.key != pressedButton[i])
i++;
if (i == pressedButton.length)
pressedButton.push(e.key);
}
function remKeyInArr(e)
{
let i;
i = 0;
while (i < pressedButton.length && e.key != pressedButton[i])
i++;
if (i != pressedButton.length)
pressedButton.splice(i, 1);
}
export { Players };

2
site/real_game/main.js
View File

@ -6,7 +6,7 @@
/* By: edbernar <edbernar@student.42angouleme. +#+ +:+ +#+ */ /* By: edbernar <edbernar@student.42angouleme. +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/28 12:05:53 by edbernar #+# #+# */ /* Created: 2024/08/28 12:05:53 by edbernar #+# #+# */
/* Updated: 2024/08/28 12:20:25 by edbernar ### ########.fr */ /* Updated: 2024/08/28 14:30:05 by edbernar ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */

19
site/real_game/node_modules/.vite/deps/_metadata.json generated vendored
View File

@ -2,34 +2,43 @@
"hash": "b5ed7c4e", "hash": "b5ed7c4e",
"configHash": "4027b9ee", "configHash": "4027b9ee",
"lockfileHash": "cd36b699", "lockfileHash": "cd36b699",
"browserHash": "cfd8b506", "browserHash": "93d0ec79",
"optimized": { "optimized": {
"stats.js": { "stats.js": {
"src": "../../stats.js/build/stats.min.js", "src": "../../stats.js/build/stats.min.js",
"file": "stats__js.js", "file": "stats__js.js",
"fileHash": "d8619cfd", "fileHash": "05a619eb",
"needsInterop": true "needsInterop": true
}, },
"three/addons/loaders/GLTFLoader.js": { "three/addons/loaders/GLTFLoader.js": {
"src": "../../three/examples/jsm/loaders/GLTFLoader.js", "src": "../../three/examples/jsm/loaders/GLTFLoader.js",
"file": "three_addons_loaders_GLTFLoader__js.js", "file": "three_addons_loaders_GLTFLoader__js.js",
"fileHash": "4aad5651", "fileHash": "748f8d46",
"needsInterop": false "needsInterop": false
}, },
"three/examples/jsm/Addons.js": { "three/examples/jsm/Addons.js": {
"src": "../../three/examples/jsm/Addons.js", "src": "../../three/examples/jsm/Addons.js",
"file": "three_examples_jsm_Addons__js.js", "file": "three_examples_jsm_Addons__js.js",
"fileHash": "1875a922", "fileHash": "61a49f6c",
"needsInterop": false "needsInterop": false
}, },
"three": { "three": {
"src": "../../three/build/three.module.js", "src": "../../three/build/three.module.js",
"file": "three.js", "file": "three.js",
"fileHash": "0e700c17", "fileHash": "9f980d32",
"needsInterop": false
},
"three/examples/jsm/controls/OrbitControls.js": {
"src": "../../three/examples/jsm/controls/OrbitControls.js",
"file": "three_examples_jsm_controls_OrbitControls__js.js",
"fileHash": "7f2e8493",
"needsInterop": false "needsInterop": false
} }
}, },
"chunks": { "chunks": {
"chunk-X4PC2K6Q": {
"file": "chunk-X4PC2K6Q.js"
},
"chunk-PJQOQ23Z": { "chunk-PJQOQ23Z": {
"file": "chunk-PJQOQ23Z.js" "file": "chunk-PJQOQ23Z.js"
}, },

791
site/real_game/node_modules/.vite/deps/chunk-X4PC2K6Q.js generated vendored Normal file
View File

@ -0,0 +1,791 @@
import {
EventDispatcher,
MOUSE,
MathUtils,
Plane,
Quaternion,
Ray,
Spherical,
TOUCH,
Vector2,
Vector3
} from "./chunk-IS2ZBFBB.js";
// node_modules/three/examples/jsm/controls/OrbitControls.js
var _changeEvent = { type: "change" };
var _startEvent = { type: "start" };
var _endEvent = { type: "end" };
var _ray = new Ray();
var _plane = new Plane();
var TILT_LIMIT = Math.cos(70 * MathUtils.DEG2RAD);
var OrbitControls = class extends EventDispatcher {
constructor(object, domElement) {
super();
this.object = object;
this.domElement = domElement;
this.domElement.style.touchAction = "none";
this.enabled = true;
this.target = new Vector3();
this.cursor = new Vector3();
this.minDistance = 0;
this.maxDistance = Infinity;
this.minZoom = 0;
this.maxZoom = Infinity;
this.minTargetRadius = 0;
this.maxTargetRadius = Infinity;
this.minPolarAngle = 0;
this.maxPolarAngle = Math.PI;
this.minAzimuthAngle = -Infinity;
this.maxAzimuthAngle = Infinity;
this.enableDamping = false;
this.dampingFactor = 0.05;
this.enableZoom = true;
this.zoomSpeed = 1;
this.enableRotate = true;
this.rotateSpeed = 1;
this.enablePan = true;
this.panSpeed = 1;
this.screenSpacePanning = true;
this.keyPanSpeed = 7;
this.zoomToCursor = false;
this.autoRotate = false;
this.autoRotateSpeed = 2;
this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" };
this.mouseButtons = { LEFT: MOUSE.ROTATE, MIDDLE: MOUSE.DOLLY, RIGHT: MOUSE.PAN };
this.touches = { ONE: TOUCH.ROTATE, TWO: TOUCH.DOLLY_PAN };
this.target0 = this.target.clone();
this.position0 = this.object.position.clone();
this.zoom0 = this.object.zoom;
this._domElementKeyEvents = null;
this.getPolarAngle = function() {
return spherical.phi;
};
this.getAzimuthalAngle = function() {
return spherical.theta;
};
this.getDistance = function() {
return this.object.position.distanceTo(this.target);
};
this.listenToKeyEvents = function(domElement2) {
domElement2.addEventListener("keydown", onKeyDown);
this._domElementKeyEvents = domElement2;
};
this.stopListenToKeyEvents = function() {
this._domElementKeyEvents.removeEventListener("keydown", onKeyDown);
this._domElementKeyEvents = null;
};
this.saveState = function() {
scope.target0.copy(scope.target);
scope.position0.copy(scope.object.position);
scope.zoom0 = scope.object.zoom;
};
this.reset = function() {
scope.target.copy(scope.target0);
scope.object.position.copy(scope.position0);
scope.object.zoom = scope.zoom0;
scope.object.updateProjectionMatrix();
scope.dispatchEvent(_changeEvent);
scope.update();
state = STATE.NONE;
};
this.update = function() {
const offset = new Vector3();
const quat = new Quaternion().setFromUnitVectors(object.up, new Vector3(0, 1, 0));
const quatInverse = quat.clone().invert();
const lastPosition = new Vector3();
const lastQuaternion = new Quaternion();
const lastTargetPosition = new Vector3();
const twoPI = 2 * Math.PI;
return function update(deltaTime = null) {
const position = scope.object.position;
offset.copy(position).sub(scope.target);
offset.applyQuaternion(quat);
spherical.setFromVector3(offset);
if (scope.autoRotate && state === STATE.NONE) {
rotateLeft(getAutoRotationAngle(deltaTime));
}
if (scope.enableDamping) {
spherical.theta += sphericalDelta.theta * scope.dampingFactor;
spherical.phi += sphericalDelta.phi * scope.dampingFactor;
} else {
spherical.theta += sphericalDelta.theta;
spherical.phi += sphericalDelta.phi;
}
let min = scope.minAzimuthAngle;
let max = scope.maxAzimuthAngle;
if (isFinite(min) && isFinite(max)) {
if (min < -Math.PI) min += twoPI;
else if (min > Math.PI) min -= twoPI;
if (max < -Math.PI) max += twoPI;
else if (max > Math.PI) max -= twoPI;
if (min <= max) {
spherical.theta = Math.max(min, Math.min(max, spherical.theta));
} else {
spherical.theta = spherical.theta > (min + max) / 2 ? Math.max(min, spherical.theta) : Math.min(max, spherical.theta);
}
}
spherical.phi = Math.max(scope.minPolarAngle, Math.min(scope.maxPolarAngle, spherical.phi));
spherical.makeSafe();
if (scope.enableDamping === true) {
scope.target.addScaledVector(panOffset, scope.dampingFactor);
} else {
scope.target.add(panOffset);
}
scope.target.sub(scope.cursor);
scope.target.clampLength(scope.minTargetRadius, scope.maxTargetRadius);
scope.target.add(scope.cursor);
let zoomChanged = false;
if (scope.zoomToCursor && performCursorZoom || scope.object.isOrthographicCamera) {
spherical.radius = clampDistance(spherical.radius);
} else {
const prevRadius = spherical.radius;
spherical.radius = clampDistance(spherical.radius * scale);
zoomChanged = prevRadius != spherical.radius;
}
offset.setFromSpherical(spherical);
offset.applyQuaternion(quatInverse);
position.copy(scope.target).add(offset);
scope.object.lookAt(scope.target);
if (scope.enableDamping === true) {
sphericalDelta.theta *= 1 - scope.dampingFactor;
sphericalDelta.phi *= 1 - scope.dampingFactor;
panOffset.multiplyScalar(1 - scope.dampingFactor);
} else {
sphericalDelta.set(0, 0, 0);
panOffset.set(0, 0, 0);
}
if (scope.zoomToCursor && performCursorZoom) {
let newRadius = null;
if (scope.object.isPerspectiveCamera) {
const prevRadius = offset.length();
newRadius = clampDistance(prevRadius * scale);
const radiusDelta = prevRadius - newRadius;
scope.object.position.addScaledVector(dollyDirection, radiusDelta);
scope.object.updateMatrixWorld();
zoomChanged = !!radiusDelta;
} else if (scope.object.isOrthographicCamera) {
const mouseBefore = new Vector3(mouse.x, mouse.y, 0);
mouseBefore.unproject(scope.object);
const prevZoom = scope.object.zoom;
scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / scale));
scope.object.updateProjectionMatrix();
zoomChanged = prevZoom !== scope.object.zoom;
const mouseAfter = new Vector3(mouse.x, mouse.y, 0);
mouseAfter.unproject(scope.object);
scope.object.position.sub(mouseAfter).add(mouseBefore);
scope.object.updateMatrixWorld();
newRadius = offset.length();
} else {
console.warn("WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled.");
scope.zoomToCursor = false;
}
if (newRadius !== null) {
if (this.screenSpacePanning) {
scope.target.set(0, 0, -1).transformDirection(scope.object.matrix).multiplyScalar(newRadius).add(scope.object.position);
} else {
_ray.origin.copy(scope.object.position);
_ray.direction.set(0, 0, -1).transformDirection(scope.object.matrix);
if (Math.abs(scope.object.up.dot(_ray.direction)) < TILT_LIMIT) {
object.lookAt(scope.target);
} else {
_plane.setFromNormalAndCoplanarPoint(scope.object.up, scope.target);
_ray.intersectPlane(_plane, scope.target);
}
}
}
} else if (scope.object.isOrthographicCamera) {
const prevZoom = scope.object.zoom;
scope.object.zoom = Math.max(scope.minZoom, Math.min(scope.maxZoom, scope.object.zoom / scale));
if (prevZoom !== scope.object.zoom) {
scope.object.updateProjectionMatrix();
zoomChanged = true;
}
}
scale = 1;
performCursorZoom = false;
if (zoomChanged || lastPosition.distanceToSquared(scope.object.position) > EPS || 8 * (1 - lastQuaternion.dot(scope.object.quaternion)) > EPS || lastTargetPosition.distanceToSquared(scope.target) > EPS) {
scope.dispatchEvent(_changeEvent);
lastPosition.copy(scope.object.position);
lastQuaternion.copy(scope.object.quaternion);
lastTargetPosition.copy(scope.target);
return true;
}
return false;
};
}();
this.dispose = function() {
scope.domElement.removeEventListener("contextmenu", onContextMenu);
scope.domElement.removeEventListener("pointerdown", onPointerDown);
scope.domElement.removeEventListener("pointercancel", onPointerUp);
scope.domElement.removeEventListener("wheel", onMouseWheel);
scope.domElement.removeEventListener("pointermove", onPointerMove);
scope.domElement.removeEventListener("pointerup", onPointerUp);
const document2 = scope.domElement.getRootNode();
document2.removeEventListener("keydown", interceptControlDown, { capture: true });
if (scope._domElementKeyEvents !== null) {
scope._domElementKeyEvents.removeEventListener("keydown", onKeyDown);
scope._domElementKeyEvents = null;
}
};
const scope = this;
const STATE = {
NONE: -1,
ROTATE: 0,
DOLLY: 1,
PAN: 2,
TOUCH_ROTATE: 3,
TOUCH_PAN: 4,
TOUCH_DOLLY_PAN: 5,
TOUCH_DOLLY_ROTATE: 6
};
let state = STATE.NONE;
const EPS = 1e-6;
const spherical = new Spherical();
const sphericalDelta = new Spherical();
let scale = 1;
const panOffset = new Vector3();
const rotateStart = new Vector2();
const rotateEnd = new Vector2();
const rotateDelta = new Vector2();
const panStart = new Vector2();
const panEnd = new Vector2();
const panDelta = new Vector2();
const dollyStart = new Vector2();
const dollyEnd = new Vector2();
const dollyDelta = new Vector2();
const dollyDirection = new Vector3();
const mouse = new Vector2();
let performCursorZoom = false;
const pointers = [];
const pointerPositions = {};
let controlActive = false;
function getAutoRotationAngle(deltaTime) {
if (deltaTime !== null) {
return 2 * Math.PI / 60 * scope.autoRotateSpeed * deltaTime;
} else {
return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;
}
}
function getZoomScale(delta) {
const normalizedDelta = Math.abs(delta * 0.01);
return Math.pow(0.95, scope.zoomSpeed * normalizedDelta);
}
function rotateLeft(angle) {
sphericalDelta.theta -= angle;
}
function rotateUp(angle) {
sphericalDelta.phi -= angle;
}
const panLeft = function() {
const v = new Vector3();
return function panLeft2(distance, objectMatrix) {
v.setFromMatrixColumn(objectMatrix, 0);
v.multiplyScalar(-distance);
panOffset.add(v);
};
}();
const panUp = function() {
const v = new Vector3();
return function panUp2(distance, objectMatrix) {
if (scope.screenSpacePanning === true) {
v.setFromMatrixColumn(objectMatrix, 1);
} else {
v.setFromMatrixColumn(objectMatrix, 0);
v.crossVectors(scope.object.up, v);
}
v.multiplyScalar(distance);
panOffset.add(v);
};
}();
const pan = function() {
const offset = new Vector3();
return function pan2(deltaX, deltaY) {
const element = scope.domElement;
if (scope.object.isPerspectiveCamera) {
const position = scope.object.position;
offset.copy(position).sub(scope.target);
let targetDistance = offset.length();
targetDistance *= Math.tan(scope.object.fov / 2 * Math.PI / 180);
panLeft(2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix);
panUp(2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix);
} else if (scope.object.isOrthographicCamera) {
panLeft(deltaX * (scope.object.right - scope.object.left) / scope.object.zoom / element.clientWidth, scope.object.matrix);
panUp(deltaY * (scope.object.top - scope.object.bottom) / scope.object.zoom / element.clientHeight, scope.object.matrix);
} else {
console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.");
scope.enablePan = false;
}
};
}();
function dollyOut(dollyScale) {
if (scope.object.isPerspectiveCamera || scope.object.isOrthographicCamera) {
scale /= dollyScale;
} else {
console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
scope.enableZoom = false;
}
}
function dollyIn(dollyScale) {
if (scope.object.isPerspectiveCamera || scope.object.isOrthographicCamera) {
scale *= dollyScale;
} else {
console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.");
scope.enableZoom = false;
}
}
function updateZoomParameters(x, y) {
if (!scope.zoomToCursor) {
return;
}
performCursorZoom = true;
const rect = scope.domElement.getBoundingClientRect();
const dx = x - rect.left;
const dy = y - rect.top;
const w = rect.width;
const h = rect.height;
mouse.x = dx / w * 2 - 1;
mouse.y = -(dy / h) * 2 + 1;
dollyDirection.set(mouse.x, mouse.y, 1).unproject(scope.object).sub(scope.object.position).normalize();
}
function clampDistance(dist) {
return Math.max(scope.minDistance, Math.min(scope.maxDistance, dist));
}
function handleMouseDownRotate(event) {
rotateStart.set(event.clientX, event.clientY);
}
function handleMouseDownDolly(event) {
updateZoomParameters(event.clientX, event.clientX);
dollyStart.set(event.clientX, event.clientY);
}
function handleMouseDownPan(event) {
panStart.set(event.clientX, event.clientY);
}
function handleMouseMoveRotate(event) {
rotateEnd.set(event.clientX, event.clientY);
rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
const element = scope.domElement;
rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
rotateStart.copy(rotateEnd);
scope.update();
}
function handleMouseMoveDolly(event) {
dollyEnd.set(event.clientX, event.clientY);
dollyDelta.subVectors(dollyEnd, dollyStart);
if (dollyDelta.y > 0) {
dollyOut(getZoomScale(dollyDelta.y));
} else if (dollyDelta.y < 0) {
dollyIn(getZoomScale(dollyDelta.y));
}
dollyStart.copy(dollyEnd);
scope.update();
}
function handleMouseMovePan(event) {
panEnd.set(event.clientX, event.clientY);
panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
pan(panDelta.x, panDelta.y);
panStart.copy(panEnd);
scope.update();
}
function handleMouseWheel(event) {
updateZoomParameters(event.clientX, event.clientY);
if (event.deltaY < 0) {
dollyIn(getZoomScale(event.deltaY));
} else if (event.deltaY > 0) {
dollyOut(getZoomScale(event.deltaY));
}
scope.update();
}
function handleKeyDown(event) {
let needsUpdate = false;
switch (event.code) {
case scope.keys.UP:
if (event.ctrlKey || event.metaKey || event.shiftKey) {
rotateUp(2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight);
} else {
pan(0, scope.keyPanSpeed);
}
needsUpdate = true;
break;
case scope.keys.BOTTOM:
if (event.ctrlKey || event.metaKey || event.shiftKey) {
rotateUp(-2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight);
} else {
pan(0, -scope.keyPanSpeed);
}
needsUpdate = true;
break;
case scope.keys.LEFT:
if (event.ctrlKey || event.metaKey || event.shiftKey) {
rotateLeft(2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight);
} else {
pan(scope.keyPanSpeed, 0);
}
needsUpdate = true;
break;
case scope.keys.RIGHT:
if (event.ctrlKey || event.metaKey || event.shiftKey) {
rotateLeft(-2 * Math.PI * scope.rotateSpeed / scope.domElement.clientHeight);
} else {
pan(-scope.keyPanSpeed, 0);
}
needsUpdate = true;
break;
}
if (needsUpdate) {
event.preventDefault();
scope.update();
}
}
function handleTouchStartRotate(event) {
if (pointers.length === 1) {
rotateStart.set(event.pageX, event.pageY);
} else {
const position = getSecondPointerPosition(event);
const x = 0.5 * (event.pageX + position.x);
const y = 0.5 * (event.pageY + position.y);
rotateStart.set(x, y);
}
}
function handleTouchStartPan(event) {
if (pointers.length === 1) {
panStart.set(event.pageX, event.pageY);
} else {
const position = getSecondPointerPosition(event);
const x = 0.5 * (event.pageX + position.x);
const y = 0.5 * (event.pageY + position.y);
panStart.set(x, y);
}
}
function handleTouchStartDolly(event) {
const position = getSecondPointerPosition(event);
const dx = event.pageX - position.x;
const dy = event.pageY - position.y;
const distance = Math.sqrt(dx * dx + dy * dy);
dollyStart.set(0, distance);
}
function handleTouchStartDollyPan(event) {
if (scope.enableZoom) handleTouchStartDolly(event);
if (scope.enablePan) handleTouchStartPan(event);
}
function handleTouchStartDollyRotate(event) {
if (scope.enableZoom) handleTouchStartDolly(event);
if (scope.enableRotate) handleTouchStartRotate(event);
}
function handleTouchMoveRotate(event) {
if (pointers.length == 1) {
rotateEnd.set(event.pageX, event.pageY);
} else {
const position = getSecondPointerPosition(event);
const x = 0.5 * (event.pageX + position.x);
const y = 0.5 * (event.pageY + position.y);
rotateEnd.set(x, y);
}
rotateDelta.subVectors(rotateEnd, rotateStart).multiplyScalar(scope.rotateSpeed);
const element = scope.domElement;
rotateLeft(2 * Math.PI * rotateDelta.x / element.clientHeight);
rotateUp(2 * Math.PI * rotateDelta.y / element.clientHeight);
rotateStart.copy(rotateEnd);
}
function handleTouchMovePan(event) {
if (pointers.length === 1) {
panEnd.set(event.pageX, event.pageY);
} else {
const position = getSecondPointerPosition(event);
const x = 0.5 * (event.pageX + position.x);
const y = 0.5 * (event.pageY + position.y);
panEnd.set(x, y);
}
panDelta.subVectors(panEnd, panStart).multiplyScalar(scope.panSpeed);
pan(panDelta.x, panDelta.y);
panStart.copy(panEnd);
}
function handleTouchMoveDolly(event) {
const position = getSecondPointerPosition(event);
const dx = event.pageX - position.x;
const dy = event.pageY - position.y;
const distance = Math.sqrt(dx * dx + dy * dy);
dollyEnd.set(0, distance);
dollyDelta.set(0, Math.pow(dollyEnd.y / dollyStart.y, scope.zoomSpeed));
dollyOut(dollyDelta.y);
dollyStart.copy(dollyEnd);
const centerX = (event.pageX + position.x) * 0.5;
const centerY = (event.pageY + position.y) * 0.5;
updateZoomParameters(centerX, centerY);
}
function handleTouchMoveDollyPan(event) {
if (scope.enableZoom) handleTouchMoveDolly(event);
if (scope.enablePan) handleTouchMovePan(event);
}
function handleTouchMoveDollyRotate(event) {
if (scope.enableZoom) handleTouchMoveDolly(event);
if (scope.enableRotate) handleTouchMoveRotate(event);
}
function onPointerDown(event) {
if (scope.enabled === false) return;
if (pointers.length === 0) {
scope.domElement.setPointerCapture(event.pointerId);
scope.domElement.addEventListener("pointermove", onPointerMove);
scope.domElement.addEventListener("pointerup", onPointerUp);
}
if (isTrackingPointer(event)) return;
addPointer(event);
if (event.pointerType === "touch") {
onTouchStart(event);
} else {
onMouseDown(event);
}
}
function onPointerMove(event) {
if (scope.enabled === false) return;
if (event.pointerType === "touch") {
onTouchMove(event);
} else {
onMouseMove(event);
}
}
function onPointerUp(event) {
removePointer(event);
switch (pointers.length) {
case 0:
scope.domElement.releasePointerCapture(event.pointerId);
scope.domElement.removeEventListener("pointermove", onPointerMove);
scope.domElement.removeEventListener("pointerup", onPointerUp);
scope.dispatchEvent(_endEvent);
state = STATE.NONE;
break;
case 1:
const pointerId = pointers[0];
const position = pointerPositions[pointerId];
onTouchStart({ pointerId, pageX: position.x, pageY: position.y });
break;
}
}
function onMouseDown(event) {
let mouseAction;
switch (event.button) {
case 0:
mouseAction = scope.mouseButtons.LEFT;
break;
case 1:
mouseAction = scope.mouseButtons.MIDDLE;
break;
case 2:
mouseAction = scope.mouseButtons.RIGHT;
break;
default:
mouseAction = -1;
}
switch (mouseAction) {
case MOUSE.DOLLY:
if (scope.enableZoom === false) return;
handleMouseDownDolly(event);
state = STATE.DOLLY;
break;
case MOUSE.ROTATE:
if (event.ctrlKey || event.metaKey || event.shiftKey) {
if (scope.enablePan === false) return;
handleMouseDownPan(event);
state = STATE.PAN;
} else {
if (scope.enableRotate === false) return;
handleMouseDownRotate(event);
state = STATE.ROTATE;
}
break;
case MOUSE.PAN:
if (event.ctrlKey || event.metaKey || event.shiftKey) {
if (scope.enableRotate === false) return;
handleMouseDownRotate(event);
state = STATE.ROTATE;
} else {
if (scope.enablePan === false) return;
handleMouseDownPan(event);
state = STATE.PAN;
}
break;
default:
state = STATE.NONE;
}
if (state !== STATE.NONE) {
scope.dispatchEvent(_startEvent);
}
}
function onMouseMove(event) {
switch (state) {
case STATE.ROTATE:
if (scope.enableRotate === false) return;
handleMouseMoveRotate(event);
break;
case STATE.DOLLY:
if (scope.enableZoom === false) return;
handleMouseMoveDolly(event);
break;
case STATE.PAN:
if (scope.enablePan === false) return;
handleMouseMovePan(event);
break;
}
}
function onMouseWheel(event) {
if (scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE) return;
event.preventDefault();
scope.dispatchEvent(_startEvent);
handleMouseWheel(customWheelEvent(event));
scope.dispatchEvent(_endEvent);
}
function customWheelEvent(event) {
const mode = event.deltaMode;
const newEvent = {
clientX: event.clientX,
clientY: event.clientY,
deltaY: event.deltaY
};
switch (mode) {
case 1:
newEvent.deltaY *= 16;
break;
case 2:
newEvent.deltaY *= 100;
break;
}
if (event.ctrlKey && !controlActive) {
newEvent.deltaY *= 10;
}
return newEvent;
}
function interceptControlDown(event) {
if (event.key === "Control") {
controlActive = true;
const document2 = scope.domElement.getRootNode();
document2.addEventListener("keyup", interceptControlUp, { passive: true, capture: true });
}
}
function interceptControlUp(event) {
if (event.key === "Control") {
controlActive = false;
const document2 = scope.domElement.getRootNode();
document2.removeEventListener("keyup", interceptControlUp, { passive: true, capture: true });
}
}
function onKeyDown(event) {
if (scope.enabled === false || scope.enablePan === false) return;
handleKeyDown(event);
}
function onTouchStart(event) {
trackPointer(event);
switch (pointers.length) {
case 1:
switch (scope.touches.ONE) {
case TOUCH.ROTATE:
if (scope.enableRotate === false) return;
handleTouchStartRotate(event);
state = STATE.TOUCH_ROTATE;
break;
case TOUCH.PAN:
if (scope.enablePan === false) return;
handleTouchStartPan(event);
state = STATE.TOUCH_PAN;
break;
default:
state = STATE.NONE;
}
break;
case 2:
switch (scope.touches.TWO) {
case TOUCH.DOLLY_PAN:
if (scope.enableZoom === false && scope.enablePan === false) return;
handleTouchStartDollyPan(event);
state = STATE.TOUCH_DOLLY_PAN;
break;
case TOUCH.DOLLY_ROTATE:
if (scope.enableZoom === false && scope.enableRotate === false) return;
handleTouchStartDollyRotate(event);
state = STATE.TOUCH_DOLLY_ROTATE;
break;
default:
state = STATE.NONE;
}
break;
default:
state = STATE.NONE;
}
if (state !== STATE.NONE) {
scope.dispatchEvent(_startEvent);
}
}
function onTouchMove(event) {
trackPointer(event);
switch (state) {
case STATE.TOUCH_ROTATE:
if (scope.enableRotate === false) return;
handleTouchMoveRotate(event);
scope.update();
break;
case STATE.TOUCH_PAN:
if (scope.enablePan === false) return;
handleTouchMovePan(event);
scope.update();
break;
case STATE.TOUCH_DOLLY_PAN:
if (scope.enableZoom === false && scope.enablePan === false) return;
handleTouchMoveDollyPan(event);
scope.update();
break;
case STATE.TOUCH_DOLLY_ROTATE:
if (scope.enableZoom === false && scope.enableRotate === false) return;
handleTouchMoveDollyRotate(event);
scope.update();
break;
default:
state = STATE.NONE;
}
}
function onContextMenu(event) {
if (scope.enabled === false) return;
event.preventDefault();
}
function addPointer(event) {
pointers.push(event.pointerId);
}
function removePointer(event) {
delete pointerPositions[event.pointerId];
for (let i = 0; i < pointers.length; i++) {
if (pointers[i] == event.pointerId) {
pointers.splice(i, 1);
return;
}
}
}
function isTrackingPointer(event) {
for (let i = 0; i < pointers.length; i++) {
if (pointers[i] == event.pointerId) return true;
}
return false;
}
function trackPointer(event) {
let position = pointerPositions[event.pointerId];
if (position === void 0) {
position = new Vector2();
pointerPositions[event.pointerId] = position;
}
position.set(event.pageX, event.pageY);
}
function getSecondPointerPosition(event) {
const pointerId = event.pointerId === pointers[0] ? pointers[1] : pointers[0];
return pointerPositions[pointerId];
}
scope.domElement.addEventListener("contextmenu", onContextMenu);
scope.domElement.addEventListener("pointerdown", onPointerDown);
scope.domElement.addEventListener("pointercancel", onPointerUp);
scope.domElement.addEventListener("wheel", onMouseWheel, { passive: false });
const document = scope.domElement.getRootNode();
document.addEventListener("keydown", interceptControlDown, { passive: true, capture: true });
this.update();
}
};
export {
OrbitControls
};
//# sourceMappingURL=chunk-X4PC2K6Q.js.map

7
site/real_game/node_modules/.vite/deps/chunk-X4PC2K6Q.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

879
site/real_game/node_modules/.vite/deps/three_examples_jsm_Addons__js.js generated vendored
View File

File diff suppressed because it is too large Load Diff

8
site/real_game/node_modules/.vite/deps/three_examples_jsm_Addons__js.js.map generated vendored
View File

File diff suppressed because one or more lines are too long

9
site/real_game/node_modules/.vite/deps/three_examples_jsm_controls_OrbitControls__js.js generated vendored Normal file
View File

@ -0,0 +1,9 @@
import {
OrbitControls
} from "./chunk-X4PC2K6Q.js";
import "./chunk-IS2ZBFBB.js";
import "./chunk-HKJ2B2AA.js";
export {
OrbitControls
};
//# sourceMappingURL=three_examples_jsm_controls_OrbitControls__js.js.map

7
site/real_game/node_modules/.vite/deps/three_examples_jsm_controls_OrbitControls__js.js.map generated vendored Normal file
View File

@ -0,0 +1,7 @@
{
"version": 3,
"sources": [],
"sourcesContent": [],
"mappings": "",
"names": []
}