This commit is contained in:
Ladebeze66 2024-09-17 12:14:07 +02:00
parent c6b8902629
commit 00cccbfa86
41 changed files with 0 additions and 5626 deletions

6
.gitignore vendored
View File

@ -1,6 +0,0 @@
venv/
__pycache__/
data/
.env
makefile
logs/django.log

View File

@ -1,18 +0,0 @@
FROM python:latest
# Set environment variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1
WORKDIR /transcendence
RUN apt update && apt upgrade -y
COPY requirements.txt .
COPY manage.py .
RUN python3 -m venv venv
RUN venv/bin/pip3 install --upgrade pip
RUN venv/bin/pip3 install --no-cache-dir -r requirements.txt
EXPOSE 8080

View File

@ -1,28 +0,0 @@
input {
file {
path => "/usr/share/logstash/logs/django.log"
start_position => "beginning"
sincedb_path => "/dev/null"
codec => "json"
}
}
filter {
json {
source => "message"
target => "json_message"
}
}
output {
elasticsearch {
hosts => ["https://es01:9200"]
user => "elastic"
password => "${ELASTIC_PASSWORD}"
ssl_enabled => true
ssl_certificate_authorities => "/usr/share/logstash/certs/ca/ca.crt"
ssl_verification_mode => "full"
index => "django-logs-%{+YYYY.MM.dd}"
}
stdout { codec => rubydebug }
}

View File

@ -1,240 +0,0 @@
services:
setup:
image: docker.elastic.co/elasticsearch/elasticsearch:${STACK_VERSION}
container_name: setup
user: "0"
volumes:
- certs:/usr/share/elasticsearch/config/certs
command: >
bash -c '
if [ x${ELASTIC_PASSWORD} == x ]; then
echo "Set the ELASTIC_PASSWORD environment variable in the .env file";
exit 1;
elif [ x${KIBANA_PASSWORD} == x ]; then
echo "Set the KIBANA_PASSWORD environment variable in the .env file";
exit 1;
fi;
if [ ! -f config/certs/ca.zip ]; then
echo "Creating CA";
bin/elasticsearch-certutil ca --silent --pem -out config/certs/ca.zip;
unzip config/certs/ca.zip -d config/certs;
fi;
if [ ! -f config/certs/certs.zip ]; then
echo "Creating certs";
echo -ne \
"instances:\n"\
" - name: es01\n"\
" dns:\n"\
" - es01\n"\
" - localhost\n"\
" ip:\n"\
" - 127.0.0.1\n"\
" - name: kibana\n"\
" dns:\n"\
" - kibana\n"\
" - localhost\n"\
" ip:\n"\
" - 127.0.0.1\n"\
> config/certs/instances.yml;
bin/elasticsearch-certutil cert --silent --pem -out config/certs/certs.zip --in config/certs/instances.yml --ca-cert config/certs/ca/ca.crt --ca-key config/certs/ca/ca.key;
unzip config/certs/certs.zip -d config/certs;
fi;
echo "Setting file permissions"
chown -R root:root config/certs;
find . -type d -exec chmod 750 \{\} \;;
find . -type f -exec chmod 640 \{\} \;;
echo "Waiting for Elasticsearch availability";
until curl -s --cacert config/certs/ca/ca.crt https://es01:9200 | grep -q "missing authentication credentials"; do sleep 30; done;
echo "Setting kibana_system password";
until curl -s -X POST --cacert config/certs/ca/ca.crt -u "elastic:${ELASTIC_PASSWORD}" -H "Content-Type: application/json" https://es01:9200/_security/user/kibana_system/_password -d "{\"password\":\"${KIBANA_PASSWORD}\"}" | grep -q "^{}"; do sleep 10; done;
echo "All done!";
'
healthcheck:
test: ["CMD-SHELL", "[ -f config/certs/es01/es01.crt ]"]
interval: 1s
timeout: 5s
retries: 120
backend:
build:
context: .
dockerfile: Dockerfile
image: backend
container_name: backend
restart: always
command: /bin/sh -c "sleep 5 &&
venv/bin/python manage.py makemigrations --noinput &&
venv/bin/python manage.py migrate --noinput &&
venv/bin/python manage.py collectstatic --noinput &&
venv/bin/daphne -b 0.0.0.0 -p 8080 pong.asgi:application"
volumes:
- pong:/transcendence/pong
- pong_django_logs:/transcendence/logs
ports:
- 8080:8080
networks:
- app-network
environment:
DB_HOST: db
DB_PORT: 5432
DB_NAME: ${POSTGRES_DB}
DB_USER: ${POSTGRES_USER}
DB_PASSWORD: ${POSTGRES_PASSWORD}
depends_on:
- db
healthcheck:
test: ["CMD-SHELL", "curl", "http://localhost:8080"]
interval: 30s
timeout: 10s
retries: 3
start_period: 10s
db:
image: postgres:latest
container_name: postgres
restart: always
volumes:
- pong_pg_data:/var/lib/postgresql/data
ports:
- "5432:5432"
networks:
- app-network
environment:
POSTGRES_DB: ${POSTGRES_DB}
POSTGRES_USER: ${POSTGRES_USER}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
interval: 10s
timeout: 5s
retries: 5
es01:
image: docker.elastic.co/elasticsearch/elasticsearch:${STACK_VERSION}
container_name: es01
depends_on:
setup:
condition: service_healthy
volumes:
- certs:/usr/share/elasticsearch/config/certs:ro
- pong_es_data_01:/usr/share/elasticsearch/data
labels:
co.elastic.logs/module: elasticsearch
ports:
- 9200:9200
environment:
- node.name=es01
- cluster.name=${CLUSTER_NAME}
- discovery.type=single-node
- ELASTIC_PASSWORD=${ELASTIC_PASSWORD}
- bootstrap.memory_lock=true
- xpack.security.enabled=true
- xpack.security.http.ssl.enabled=true
- xpack.security.http.ssl.key=certs/es01/es01.key
- xpack.security.http.ssl.certificate=certs/es01/es01.crt
- xpack.security.http.ssl.certificate_authorities=certs/ca/ca.crt
- xpack.security.transport.ssl.enabled=true
- xpack.security.transport.ssl.key=certs/es01/es01.key
- xpack.security.transport.ssl.certificate=certs/es01/es01.crt
- xpack.security.transport.ssl.certificate_authorities=certs/ca/ca.crt
- xpack.security.transport.ssl.verification_mode=certificate
- xpack.license.self_generated.type=${LICENSE}
healthcheck:
test:
[
"CMD-SHELL",
"curl -s --cacert config/certs/ca/ca.crt https://localhost:9200 | grep -q 'missing authentication credentials'",
]
interval: 10s
timeout: 10s
retries: 120
kibana:
image: docker.elastic.co/kibana/kibana:${STACK_VERSION}
container_name: kibana
labels:
co.elastic.logs/module: kibana
depends_on:
es01:
condition: service_healthy
volumes:
- certs:/usr/share/kibana/config/certs:ro
- pong_kibana:/usr/share/kibana/data
ports:
- 5601:5601
environment:
- SERVERNAME=kibana
- ELASTICSEARCH_HOSTS=https://es01:9200
- ELASTICSEARCH_USERNAME=${KIBANA_USERNAME}
- ELASTICSEARCH_PASSWORD=${KIBANA_PASSWORD}
- ELASTICSEARCH_SSL_CERTIFICATEAUTHORITIES=config/certs/ca/ca.crt
- XPACK_SECURITY_ENCRYPTIONKEY=${ENCRYPTION_KEY}
- XPACK_ENCRYPTEDSAVEDOBJECTS_ENCRYPTIONKEY=${ENCRYPTION_KEY}
- XPACK_REPORTING_ENCRYPTIONKEY=${ENCRYPTION_KEY}
healthcheck:
test:
[
"CMD-SHELL",
"curl -s -I http://localhost:5601 | grep -q 'HTTP/1.1 302 Found'"
]
interval: 10s
timeout: 10s
retries: 120
logstash01:
image: docker.elastic.co/logstash/logstash:${STACK_VERSION}
container_name: logstash01
labels:
co.elastic.logs/module: logstash
user: root
depends_on:
es01:
condition: service_healthy
kibana:
condition: service_healthy
volumes:
- certs:/usr/share/logstash/certs
- pong_logstash_data01:/usr/share/logstash/data
- ./config/logstash.conf:/usr/share/logstash/pipeline/logstash.conf:ro
- pong_django_logs:/usr/share/logstash/logs
ports:
- "5044:5044/udp"
command: logstash -f /usr/share/logstash/pipeline/logstash.conf
environment:
- NODE_NAME="logstash"
- ELASTIC_HOSTS=https://es01:9200
- ELASTIC_USER=${ELASTIC_USERNAME}
- ELASTIC_PASSWORD=${ELASTIC_PASSWORD}
- xpack.monitoring.enabled=false
volumes:
pong:
driver: local
driver_opts:
type: none
device: ${PROJECT_PATH}
o: bind
pong_django_logs:
driver: local
driver_opts:
type: none
device: ${DJANGO_LOGS}
o: bind
pong_pg_data:
driver: local
pong_es_data_01:
driver: local
pong_kibana:
driver: local
pong_logstash_data01:
driver: local
certs:
driver: local
networks:
app-network:
name: app-network
driver: bridge

View File

@ -1,30 +0,0 @@
# Django settings
SECRET_KEY="FollowTheWhiteRabbit"
DEBUG=True
DJANGO_ALLOWED_HOSTS=['*']
# PostgreSQL settings
POSTGRES_DB=players_db
POSTGRES_USER=42student
POSTGRES_PASSWORD=
# Django settings
DB_HOST=db
DB_PORT=5432
PWD_PATH=${PWD}
PROJECT_PATH=${PWD_PATH}/pong
# ElasticSearch settings
STACK_VERSION=8.14.3
CLUSTER_NAME=docker-cluster
LICENSE=basic
ELASTIC_USERNAME=elastic
ELASTIC_PASSWORD=
# Kibana settings
KIBANA_PORT=5601
KIBANA_USERNAME=
KIBANA_PASSWORD=
ENCRYPTION_KEY=c34d38b3a14956121ff2170e5030b471551370178f43e5626eec58b04a30fae2

View File

@ -1,41 +0,0 @@
:8080/:1 The Cross-Origin-Opener-Policy header has been ignored, because the URL's origin was untrustworthy. It was defined either in the final response or a redirect. Please deliver the response using the HTTPS protocol. You can also use the 'localhost' origin instead. See https://www.w3.org/TR/powerful-features/#potentially-trustworthy-origin and https://html.spec.whatwg.org/#the-cross-origin-opener-policy-header.
game.js:2 DOM fully loaded and parsed
game.js:48 DOM elements initialized
game.js:71 Event listeners added
game.js:186 checkUserExists called with username: dede
game.js:203 User existence check response: {exists: false}
game.js:212 handleRegister called
game.js:225 Attempting to register user: dede
game.js:250 registerUser called with username: dede
game.js:273 Registration response data: {registered: true, token: 'c4ab5fd7-4b04-4353-8d4e-ae1afb2ba793'}
game.js:275 User registered successfully: {registered: true, token: 'c4ab5fd7-4b04-4353-8d4e-ae1afb2ba793'}
game.js:229 Token stored: c4ab5fd7-4b04-4353-8d4e-ae1afb2ba793
game.js:230 User registered successfully
game.js:922 Joining room: main_room with username: dede and token: c4ab5fd7-4b04-4353-8d4e-ae1afb2ba793
game.js:929 Joining new room: main_room
game.js:846 createRoomTab: main_room with username: dede and token: c4ab5fd7-4b04-4353-8d4e-ae1afb2ba793
game.js:856 Tab for room main_room already exists.
game.js:870 Showing tab for room: main_room
game.js:778 Initializing chat WebSocket...
game.js:779 Initializing chat WebSocket for room: main_room with username: dede
game.js:877 switchRoom: main_room with username: dede and token: c4ab5fd7-4b04-4353-8d4e-ae1afb2ba793
game.js:883 Attempting to switch to room: main_room
game.js:889 Switching from room null to room main_room
game.js:783 startChatWebSocket: main_room with username: dede and token: c4ab5fd7-4b04-4353-8d4e-ae1afb2ba793
game.js:785 Attempting to connect to WebSocket for room: main_room
game.js:835 WebSocket connection stored for room: main_room
game.js:784 WebSocket connection to 'ws://172.31.141.12:8080/ws/chat/main_room/' failed:
(anonymous) @ game.js:784
game.js:831 Chat WebSocket error in room main_room: Event {isTrusted: true, type: 'error', target: WebSocket, currentTarget: WebSocket, eventPhase: 2, …}
chatSocket.onerror @ game.js:831
error
(anonymous) @ game.js:830
setTimeout
startChatWebSocket @ game.js:781
joinRoom @ game.js:932
handleRegister @ game.js:235
game.js:826 Chat WebSocket closed unexpectedly for room main_room
chatSocket.onclose @ game.js:826
game.js:754 WebSocket is already in CLOSING or CLOSED state.
sendMessage @ game.js:754
(anonymous) @ game.js:747

View File

@ -1,38 +0,0 @@
:8080/:1 The Cross-Origin-Opener-Policy header has been ignored, because the URL's origin was untrustworthy. It was defined either in the final response or a redirect. Please deliver the response using the HTTPS protocol. You can also use the 'localhost' origin instead. See https://www.w3.org/TR/powerful-features/#potentially-trustworthy-origin and https://html.spec.whatwg.org/#the-cross-origin-opener-policy-header.
game.js:2 DOM fully loaded and parsed
game.js:48 DOM elements initialized
game.js:71 Event listeners added
game.js:186 checkUserExists called with username: ferdy
game.js:203 User existence check response: {exists: false}
game.js:212 handleRegister called
game.js:225 Attempting to register user: ferdy
game.js:250 registerUser called with username: ferdy
game.js:273 Registration response data: {registered: true, token: '4d383e70-92b8-4e04-8efb-d7bdfc0dcfac'}
game.js:275 User registered successfully: {registered: true, token: '4d383e70-92b8-4e04-8efb-d7bdfc0dcfac'}
game.js:229 Token stored: 4d383e70-92b8-4e04-8efb-d7bdfc0dcfac
game.js:230 User registered successfully
game.js:922 Joining room: main_room with username: ferdy and token: 4d383e70-92b8-4e04-8efb-d7bdfc0dcfac
game.js:929 Joining new room: main_room
game.js:846 createRoomTab: main_room with username: ferdy and token: 4d383e70-92b8-4e04-8efb-d7bdfc0dcfac
game.js:856 Tab for room main_room already exists.
game.js:870 Showing tab for room: main_room
game.js:778 Initializing chat WebSocket...
game.js:779 Initializing chat WebSocket for room: main_room with username: ferdy
game.js:877 switchRoom: main_room with username: ferdy and token: 4d383e70-92b8-4e04-8efb-d7bdfc0dcfac
game.js:883 Attempting to switch to room: main_room
game.js:889 Switching from room null to room main_room
game.js:783 startChatWebSocket: main_room with username: ferdy and token: 4d383e70-92b8-4e04-8efb-d7bdfc0dcfac
game.js:785 Attempting to connect to WebSocket for room: main_room
game.js:835 WebSocket connection stored for room: main_room
game.js:784 WebSocket connection to 'ws://172.31.141.12:8080/ws/chat/main_room/' failed:
(anonymous) @ game.js:784
game.js:831 Chat WebSocket error in room main_room: Event {isTrusted: true, type: 'error', target: WebSocket, currentTarget: WebSocket, eventPhase: 2, …}isTrusted: truebubbles: falsecancelBubble: falsecancelable: falsecomposed: falsecurrentTarget: WebSocket {url: 'ws://172.31.141.12:8080/ws/chat/main_room/', readyState: 3, bufferedAmount: 0, onopen: ƒ, onerror: ƒ, …}defaultPrevented: falseeventPhase: 0returnValue: truesrcElement: WebSocket {url: 'ws://172.31.141.12:8080/ws/chat/main_room/', readyState: 3, bufferedAmount: 0, onopen: ƒ, onerror: ƒ, …}target: WebSocket {url: 'ws://172.31.141.12:8080/ws/chat/main_room/', readyState: 3, bufferedAmount: 0, onopen: ƒ, onerror: ƒ, …}timeStamp: 13273.79999999702type: "error"[[Prototype]]: Event
chatSocket.onerror @ game.js:831
error
(anonymous) @ game.js:830
setTimeout
startChatWebSocket @ game.js:781
joinRoom @ game.js:932
handleRegister @ game.js:235
game.js:826 Chat WebSocket closed unexpectedly for room main_room
chatSocket.onclose @ game.js:826

View File

@ -1,40 +0,0 @@
:8080/:1 The Cross-Origin-Opener-Policy header has been ignored, because the URL's origin was untrustworthy. It was defined either in the final response or a redirect. Please deliver the response using the HTTPS protocol. You can also use the 'localhost' origin instead. See https://www.w3.org/TR/powerful-features/#potentially-trustworthy-origin and https://html.spec.whatwg.org/#the-cross-origin-opener-policy-header.
game.js:2 DOM fully loaded and parsed
game.js:48 DOM elements initialized
game.js:71 Event listeners added
game.js:186 checkUserExists called with username: gggg
game.js:203 User existence check response: {exists: false}
game.js:212 handleRegister called
game.js:225 Attempting to register user: gggg
game.js:250 registerUser called with username: gggg
game.js:273 Registration response data: {registered: true, token: 'a6010523-60c5-460b-ac49-39097e66a376'}
game.js:275 User registered successfully: {registered: true, token: 'a6010523-60c5-460b-ac49-39097e66a376'}
game.js:229 Token stored: a6010523-60c5-460b-ac49-39097e66a376
game.js:230 User registered successfully
game.js:926 Joining room: main_room with username: gggg and token: a6010523-60c5-460b-ac49-39097e66a376
game.js:933 Joining new room: main_room
game.js:850 createRoomTab: main_room with username: gggg and token: a6010523-60c5-460b-ac49-39097e66a376
game.js:860 Tab for room main_room already exists.
game.js:874 Showing tab for room: main_room
game.js:780 Initializing chat WebSocket...
game.js:781 Initializing chat WebSocket for room: main_room with username: gggg
game.js:881 switchRoom: main_room with username: gggg and token: a6010523-60c5-460b-ac49-39097e66a376
game.js:887 Attempting to switch to room: main_room
game.js:893 Switching from room null to room main_room
game.js:785 startChatWebSocket: main_room with username: gggg and token: a6010523-60c5-460b-ac49-39097e66a376
game.js:787 Attempting to connect to WebSocket for room: main_room
game.js:838 WebSocket connection stored for room: main_room
game.js:839 Authentication username for chat-input: gggg
game.js:790 Chat WebSocket connection established in room: main_room
game.js:798 Authentication message sent with username: gggg
game.js:799 Authentication message sent for room: main_room
game.js:804 Message received from server in room main_room: {type: 'chat_message', message: ': Anonyme Vous avez rejoint le chat main_room', room: 'main_room'}message: ": Anonyme Vous avez rejoint le chat main_room"room: "main_room"type: "chat_message"[[Prototype]]: Object
game.js:814 Message displayed in chat log for room: main_room
game.js:804 Message received from server in room main_room: {type: 'authenticated', username: 'gggg'}type: "authenticated"username: "gggg"[[Prototype]]: Object
game.js:806 User authenticated for chat successfully in room: main_room
game.js:754 Sending message from username: gggg
game.js:804 Message received from server in room main_room: {type: 'chat_message', message: 'gggg: hhfghfh', room: 'main_room'}
game.js:814 Message displayed in chat log for room: main_room
game.js:754 Sending message from username: gggg
game.js:804 Message received from server in room main_room: {type: 'chat_message', message: 'gggg: fhfhfh', room: 'main_room'}
game.js:814 Message displayed in chat log for room: main_room

View File

@ -1,9 +0,0 @@
{"asctime": "2024-09-01 18:09:35,223", "levelname": "ERROR", "name": "django.request", "module": "log", "process": 25, "thread": 131470748288704, "message": "Internal Server Error: /register_user/", "taskName": null, "status_code": 500, "request": "<ASGIRequest: POST '/register_user/'>"}
{"asctime": "2024-09-01 18:19:53,264", "levelname": "ERROR", "name": "django.request", "module": "log", "process": 25, "thread": 131966181574336, "message": "Internal Server Error: /register_user/", "taskName": null, "status_code": 500, "request": "<ASGIRequest: POST '/register_user/'>"}
{"asctime": "2024-09-01 18:34:25,868", "levelname": "ERROR", "name": "django.request", "module": "log", "process": 25, "thread": 138740796229312, "message": "Internal Server Error: /register_user/", "taskName": null, "status_code": 500, "request": "<ASGIRequest: POST '/register_user/'>"}
{"asctime": "2024-09-01 18:35:04,063", "levelname": "ERROR", "name": "django.request", "module": "log", "process": 25, "thread": 138740796229312, "message": "Internal Server Error: /register_user/", "taskName": null, "status_code": 500, "request": "<ASGIRequest: POST '/register_user/'>"}
{"asctime": "2024-09-01 18:57:12,326", "levelname": "ERROR", "name": "django.request", "module": "log", "process": 25, "thread": 125916130838208, "message": "Internal Server Error: /register_user/", "taskName": null, "status_code": 500, "request": "<ASGIRequest: POST '/register_user/'>"}
{"asctime": "2024-09-01 19:05:27,423", "levelname": "ERROR", "name": "django.request", "module": "log", "process": 25, "thread": 132460855690944, "message": "Internal Server Error: /register_user/", "taskName": null, "status_code": 500, "request": "<ASGIRequest: POST '/register_user/'>"}
{"asctime": "2024-09-02 09:24:00,957", "levelname": "ERROR", "name": "django.request", "module": "log", "process": 25, "thread": 138073176278720, "message": "Internal Server Error: /register_user/", "taskName": null, "status_code": 500, "request": "<ASGIRequest: POST '/register_user/'>"}
{"asctime": "2024-09-02 09:31:57,272", "levelname": "ERROR", "name": "django.request", "module": "log", "process": 25, "thread": 129740826478272, "message": "Internal Server Error: /register_user/", "taskName": null, "status_code": 500, "request": "<ASGIRequest: POST '/register_user/'>"}
{"asctime": "2024-09-02 09:38:30,671", "levelname": "ERROR", "name": "django.request", "module": "log", "process": 25, "thread": 136981996635840, "message": "Internal Server Error: /register_user/", "taskName": null, "status_code": 500, "request": "<ASGIRequest: POST '/register_user/'>"}

View File

@ -1,49 +0,0 @@
COMPOSE_FILE=docker-compose.yml
COMPOSE=docker compose -f $(COMPOSE_FILE)
CONTAINER=$(c)
up: down
$(COMPOSE) build
$(COMPOSE) up $(CONTAINER) || true
build:
$(COMPOSE) build $(CONTAINER)
start:
$(COMPOSE) start $(CONTAINER)
stop:
$(COMPOSE) stop $(CONTAINER)
down:
$(COMPOSE) down $(CONTAINER)
destroy:
$(COMPOSE) down -v --rmi all
sudo lsof -i :5432 | awk 'NR>1 {print $$2}' | xargs sudo kill -9 || true
sudo lsof -i :80 | awk 'NR>1 {print $$2}' | xargs sudo kill -9 || true
logs:
$(COMPOSE) logs -f $(CONTAINER)
ps:
$(COMPOSE) ps
db-shell:
$(COMPOSE) exec db psql -U 42student players_db
re: destroy up
help:
@echo "Usage:"
@echo " make build [c=service] # Build images"
@echo " make up [c=service] # Start containers in detached mode"
@echo " make start [c=service] # Start existing containers"
@echo " make down [c=service] # Stop and remove containers"
@echo " make destroy # Stop and remove containers and volumes"
@echo " make stop [c=service] # Stop containers"
@echo " make logs [c=service] # Tail logs of containers"
@echo " make ps # List containers"
@echo " make help # Show this help"
.PHONY: up build start stop down destroy logs ps db-shell help

View File

@ -1,19 +0,0 @@
#!/usr/bin/env python
import os
import sys
def main():
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'pong.settings')
try:
from django.core.management import execute_from_command_line
except ImportError as exc:
raise ImportError(
"Couldn't import Django. Are you sure it's installed and "
"available on your PYTHONPATH environment variable? Did you "
"forget to activate a virtual environment?"
) from exc
execute_from_command_line(sys.argv)
if __name__ == '__main__':
main()

View File

View File

@ -1,39 +0,0 @@
# /pong/asgi.py
"""
ASGI config for pong project.
It exposes the ASGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/3.2/howto/deployment/asgi/
"""
import os
import django
import logging
logger = logging.getLogger(__name__)
logger.debug("Setting default DJANGO_SETTINGS_MODULE to 'pong.settings'")
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'pong.settings')
logger.debug("Initializing Django setup")
django.setup()
from django.core.asgi import get_asgi_application
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
import pong.game.routing
logger.debug("Configuring ProtocolTypeRouter")
application = ProtocolTypeRouter({
"http": get_asgi_application(),
"websocket": AuthMiddlewareStack(
URLRouter(
pong.game.routing.websocket_urlpatterns
)
),
})
logger.info("ASGI application configurée et prête à accepter les connexions")

View File

View File

@ -1,465 +0,0 @@
import json
from channels.generic.websocket import AsyncWebsocketConsumer
from asgiref.sync import sync_to_async
from django.contrib.auth.models import User
from channels.db import database_sync_to_async
from .matchmaking import match_maker
from .tournament import tournament_match_maker
import logging
logger = logging.getLogger(__name__)
class GameConsumer(AsyncWebsocketConsumer):
async def connect(self):
try:
await self.accept()
self.game = None
logger.info("User connected via WebSocket")
except Exception as e:
logger.error(f"Error during WebSocket connection: {str(e)}")
async def receive(self, text_data):
try:
logger.debug(f"Received data: {text_data}")
data = json.loads(text_data)
message_type = data.get('type')
if message_type == 'authenticate':
await self.authenticate(data.get('token'))
elif message_type == 'authenticate2':
await self.authenticate2(data.get('token_1'), data.get('token_2'))
elif message_type == 'authenticate3':
await self.authenticate3(data.get('token'))
elif message_type == 'key_press':
if self.game:
await self.game.handle_key_press(self, data.get('key'))
else:
await match_maker.handle_key_press(self, data.get('key'))
else:
logger.warning(f"Received unknown message type: {message_type}")
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Unknown message type'}))
except json.JSONDecodeError as e:
logger.error(f"JSON decode error: {str(e)} - Data received: {text_data}")
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Invalid JSON format'}))
except Exception as e:
logger.error(f"Error in WebSocket receive: {str(e)}")
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Internal server error'}))
async def authenticate(self, token):
if not token:
logger.error("Token is None, authentication cannot proceed")
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Token is missing'}))
return
try:
user = await self.get_user_from_token(token)
if user:
self.user = user
await self.send(text_data=json.dumps({'type': 'authenticated'}))
logger.info(f"User {self.user} authenticated")
await self.join_waiting_room()
else:
logger.warning(f"Authentication failed for token: {token}")
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed'}))
except Exception as e:
logger.error(f"Error during authentication: {str(e)}")
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Internal server error'}))
async def authenticate2(self, token_1, token_2):
try:
user = await self.get_user_from_token(token_1)
if user:
self.user = user
await self.send(text_data=json.dumps({'type': 'authenticated'}))
logger.info(f"User {self.user} authenticated with token_1")
user2 = await self.get_user_from_token2(token_2)
if user2:
self.user2 = user2
await self.send(text_data=json.dumps({'type': 'authenticated'}))
logger.info(f"User {self.user2} authenticated with token_2")
await match_maker.create_game(self, None, True)
else:
logger.warning(f"Authentication failed for token_2: {token_2}")
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed for user 2'}))
else:
logger.warning(f"Authentication failed for token_1: {token_1}")
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed for user 1'}))
except Exception as e:
logger.error(f"Error during dual authentication: {str(e)}")
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Internal server error'}))
async def authenticate3(self, token):
try:
user = await self.get_user_from_token(token)
if user:
self.user = user
await self.send(text_data=json.dumps({'type': 'authenticated'}))
logger.info(f"User {self.user} authenticated for tournament")
await self.join_tournament_waiting_room()
else:
logger.warning(f"Authentication failed for token: {token}")
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Authentication failed'}))
except Exception as e:
logger.error(f"Error during tournament authentication: {str(e)}")
await self.send(text_data=json.dumps({'type': 'error', 'message': 'Internal server error'}))
@database_sync_to_async
def get_user_from_token(self, token):
try:
user = User.objects.filter(auth_token=token).first()
logger.debug(f"User found: {user} for token: {token}")
return user
except User.DoesNotExist:
logger.warning(f"User not found for token: {token}")
return None
@database_sync_to_async
def get_user_from_token2(self, token):
try:
user2 = User.objects.filter(auth_token=token).first()
logger.debug(f"User2 found: {user2} for token: {token}")
return user2
except User.DoesNotExist:
logger.warning(f"User not found for token_2: {token}")
return None
async def join_waiting_room(self):
logger.info("Joining waiting room")
await self.send(text_data=json.dumps({'type': 'waiting_room'}))
await match_maker.add_player(self)
async def join_tournament_waiting_room(self):
logger.info("Joining tournament waiting room")
await tournament_match_maker.add_player(self)
async def disconnect(self, close_code):
try:
if self.game:
await self.game.end_game(disconnected_player=self)
await match_maker.remove_player(self)
await tournament_match_maker.remove_player(self)
logger.info(f"User {self.user.username if hasattr(self, 'user') else 'Unknown'} disconnected")
except Exception as e:
logger.error(f"Error during WebSocket disconnection: {str(e)}")
async def set_game(self, game):
logger.info(f"Setting game: {game}")
self.game = game
###################################################################CHAT###################################################################
class ChatConsumer(AsyncWebsocketConsumer):
async def connect(self):
try:
# Récupérer le nom de la room à partir de l'URL
self.room_group_name = self.scope['url_route']['kwargs']['room_name']
# Accepter la connexion WebSocket
await self.accept()
# Ajouter l'utilisateur au groupe (room)
await self.channel_layer.group_add(
self.room_group_name,
self.channel_name
)
self.username = self.scope['user'].username # Assurez-vous d'avoir un utilisateur lié à la connexion
logger.info(f"Connexion de l'utilisateur {self.username} à la room {self.room_group_name}")
# Ajouter l'utilisateur à son propre groupe personnel (pour messages directs)
except Exception as e:
logger.error(f"Erreur lors de la connexion WebSocket: {str(e)}")
async def disconnect(self, close_code):
try:
# Retirer l'utilisateur du groupe (room)
await self.channel_layer.group_discard(
self.room_group_name,
self.channel_name
)
# Retirer l'utilisateur de son groupe personnel
await self.channel_layer.group_discard(
f"user_{self.username}",
self.channel_name
)
# Envoyer un message indiquant que l'utilisateur a quitté la room
await self.chat_message(
'chat_message',
self.user.username if hasattr(self, "user") else "Unknown",
f'{self.user.username if hasattr(self, "user") else "Unknown"} a quitté le chat',
self.room_group_name
)
logger.info(f"{self.user.username if hasattr(self, 'user') else 'Unknown'} déconnecté de la room {self.room_group_name}")
except Exception as e:
logger.error(f"Erreur lors de la déconnexion WebSocket: {str(e)}")
async def receive(self, text_data):
try:
# Convertir les données JSON reçues en dictionnaire Python
data = json.loads(text_data)
message_type = data.get('type')
username = data.get('username')
message = data.get('message', None)
target_user = data.get('target_user', None)
logger.info(f"Message reçu: {data}")
if not username:
logger.error(f"Username manquant dans le message: {data}")
await self.chat_message('error', 'server', 'Username is missing', self.room_group_name)
return
# Gestion des différents types de messages
if message_type == 'authenticate':
logger.info(f"Authentification demandée pour {username}")
await self.authenticate(data.get('token'), username)
return
elif message_type == 'chat_message':
logger.info(f"Message de chat envoyé par {username}: {message}")
await self.chat_message('chat_message', username, message, self.room_group_name)
elif message_type == 'block_user':
logger.info(f"{username} tente de bloquer {target_user}")
await self.handle_block_user(data)
elif message_type == 'invite':
await self.handle_invite_user(data)
elif message_type == 'invite_response':
await self.handle_invite_response(data)
else:
logger.warning(f"Type de message non géré: {message_type}")
await self.chat_message('error', 'server', f"Unhandled message type: {message_type}", self.room_group_name)
except json.JSONDecodeError as e:
logger.error(f"Erreur de décodage JSON : {str(e)} - Données reçues : {text_data}")
await self.chat_message('error', 'server', 'Invalid JSON format', self.room_group_name)
except Exception as e:
logger.error(f"Erreur lors de la réception du message: {str(e)}")
await self.chat_message('error', 'server', 'Internal server error', self.room_group_name)
async def chat_message(self, message_type, username, message, room):
"""
Fonction générale pour envoyer tout type de message via WebSocket à tous les utilisateurs dans la room.
"""
logger.info(f"Envoi d'un message de type {message_type} de {username} dans la room {room}")
# Utilisation de channel_layer pour envoyer le message à tout le groupe (room)
await self.channel_layer.group_send(
room,
{
'type': 'send_group_message', # Nom de la méthode qui va gérer ce message
'username': username,
'message': message,
'room': room
}
)
async def send_group_message(self, event):
"""
Cette fonction est appelée par channel_layer pour envoyer des messages à tous les utilisateurs dans une room.
"""
message = event['message']
username = event.get('username', 'Anonyme')
room = event.get('room', 'unknown')
logger.info(f"Diffusion d'un message de {username} à la room {room}: {message}")
# Envoi du message à chaque utilisateur dans la room via WebSocket
await self.send(text_data=json.dumps({
'type': 'chat_message', # Le type de message qui sera renvoyé au client
'username': username,
'message': message,
'room': room
}))
async def handle_block_user(self, data):
username = data['username']
target_user = data['target_user']
logger.info(f"handle_block_user appelé avec : {data}")
if target_user == username:
logger.warning(f"{username} a tenté de se bloquer lui-même.")
await self.send(text_data=json.dumps({'type': 'error', 'message': 'You cannot block yourself'}))
return
logger.info(f"{username} a bloqué {target_user}")
# Utilisation correcte de l' f-string pour inclure la valeur de target_user
await self.send(text_data=json.dumps({
'type': 'block_user',
'message': f'Vous avez bloqué les messages de {target_user}'
}))
async def handle_invite_user(self, data):
# Récupération des informations de l'invitation
inviter = data.get('username')
target_user = data.get('target_user')
room = data.get('room')
# Validation des paramètres
if not inviter:
logger.error("Invitant manquant dans le message d'invitation")
await self.chat_message('error', 'server', 'Invitant manquant', self.room_group_name)
return
if not target_user:
logger.error("Utilisateur cible manquant dans le message d'invitation")
await self.chat_message('error', 'server', 'Utilisateur cible manquant', self.room_group_name)
return
if not room:
logger.error("Room manquante dans le message d'invitation")
await self.chat_message('error', 'server', 'Room manquante', self.room_group_name)
return
logger.info(f"Invitation envoyée de {inviter} à {target_user} dans la room {room}")
await self.chat_message('chat_message', 'server', f'{inviter} a invité {target_user} à rejoindre une partie {room}', room)
# Envoi de l'invitation
await self.channel_layer.group_send(
room,
{
'type': 'invite',
'inviter': inviter,
'target_user': target_user,
'room': room,
'message': f'{inviter} vous a invité à rejoindre la room {room}.'
}
)
async def handle_invite_response(self, data):
inviter = data.get('inviter')
username = data.get('username') # L'utilisateur invité qui répond
response = data.get('response')
room = data.get('room')
logger.info(f"{username} a répondu '{response}' à l'invitation de {inviter}")
await self.chat_message('chat_message', 'server', f'{username} a répondu {response} à l\'invitation.', room)
# Si la réponse est 'yes', informer l'invitant que l'invité a accepté
if response.lower() == 'yes':
try:
# Informer l'invitant que l'invitation a été acceptée
await self.channel_layer.group_send(
room,
{
'type': 'invite_response',
'inviter': inviter,
'username': username,
'response': response,
'room': room,
'message': f'{username} a accepté l\'invitation.'
}
)
# Informer à la fois l'invité et l'invitant que le jeu va commencer
await self.channel_layer.group_send(
room,
{
'type': 'start_quick_match',
'inviter': inviter,
'username': username,
'message': 'La partie va démarrer pour vous deux.',
}
)
except Exception as e:
logger.error(f"Error while sending invite response: {str(e)}")
await self.chat_message('error', 'server', f'Internal server error: {str(e)}', room)
# Méthode appelée pour envoyer l'invitation à l'utilisateur invité (target_user)
async def invite(self, event):
inviter = event['inviter']
message = event['message']
room = event['room']
target_user = event['target_user']
logger.info(f"invite: Envoi de l'invitation à l'utilisateur via WebSocket. Inviter={inviter}, Room={room}, Message={message}")
# Envoyer le message d'invitation via WebSocket
await self.send(text_data=json.dumps({
'type': 'invite',
'inviter': inviter,
'target_user': target_user,
'message': message,
'room': room
}))
async def handle_invite_response(self, data):
inviter = data.get('inviter')
username = data.get('username') # L'utilisateur invité qui répond
response = data.get('response')
room = data.get('room')
logger.info(f"{username} a répondu '{response}' à l'invitation de {inviter}")
await self.chat_message('chat_message', 'server', f'{username} a répondu {response} à l\'invitation.', room)
# Envoi de la réponse directement à l'invitant dans la room
await self.channel_layer.group_send(
room,
{
'type': 'invite_response', # Type de message 'invite_response'
'inviter': inviter,
'username': username,
'room': room,
'message': f'{username} a répondu {response} à l\'invitation.',
'response': response # Ajout de la réponse 'yes' ou 'no'
}
)
async def invite_response(self, event):
message = event['message']
response = event.get('response')
inviter = event.get('inviter') # Récupérer l'inviteur
logger.info(f"invite_response: Envoi de la réponse à l'invitation via WebSocket. Message={message}, Response={response}, Inviter={inviter}")
# Envoyer la réponse à l'invitation via WebSocket à l'invitant
await self.send(text_data=json.dumps({
'type': 'invite_response',
'message': message,
'response': response,
'inviter': inviter
}))
async def authenticate(self, token, username):
if not token:
logger.error("Token est manquant, l'authentification ne peut pas se poursuivre.")
await self.chat_message('error', 'server', 'Token is missing', self.room_group_name)
return
logger.info(f"Tentative d'authentification avec le token: {token} pour l'utilisateur: {username}")
try:
user = await self.get_user_from_token(token)
if user:
self.user = user
logger.info(f"Utilisateur {username} authentifié avec succès")
await self.chat_message('authenticated', username, 'Authentication successful', self.room_group_name)
await self.channel_layer.group_add(
f"user_{self.username}", # Group name unique pour cet utilisateur
self.channel_name
)
logger.info(f"Connexion de l'utilisateur {self.username} à son groupe personnel")
else:
logger.warning(f"Échec de l'authentification pour le token: {token}")
await self.chat_message('error', username, 'Authentication failed', self.room_group_name)
except Exception as e:
logger.error(f"Erreur lors de l'authentification : {str(e)}")
await self.chat_message('error', 'server', 'Internal server error', self.room_group_name)
@sync_to_async
def get_user_from_token(self, token):
try:
user = User.objects.filter(auth_token=token).first()
logger.debug(f"Utilisateur trouvé : {user} pour le token : {token}")
return user
except User.DoesNotExist:
logger.warning(f"Utilisateur non trouvé pour le token : {token}")
return None

View File

@ -1,240 +0,0 @@
# /pong/game/game.py
import json
import asyncio
import random
from datetime import datetime
from .utils import handle_game_data
from asgiref.sync import sync_to_async
class Game:
def __init__(self, game_id, player1, player2, localgame):
self.game_id = game_id
self.player1 = player1
self.player2 = player2
self.localgame = localgame
if self.localgame:
self.botgame = False
self.game_state = {
'player1_name': player1.user.username,
'player2_name': player1.user2.username,
'player1_position': 150,
'player2_position': 150,
'ball_position': {'x': 390, 'y': 190},
'ball_velocity': {'x': random.choice([-5, 5]), 'y': random.choice([-5, 5])},
'player1_score': 0,
'player2_score': 0,
'game_text': ''
}
else:
self.botgame = player2 is None
self.game_state = {
'player1_name': player1.user.username,
'player2_name': player2.user.username if player2 else 'BOT',
'player1_position': 150,
'player2_position': 150,
'ball_position': {'x': 390, 'y': 190},
'ball_velocity': {'x': random.choice([-5, 5]), 'y': random.choice([-5, 5])},
'player1_score': 0,
'player2_score': 0,
'game-text': ''
}
self.speed = 1
self.game_loop_task = None
self.ended = False
self.p1_mov = 0
self.p2_mov = 0
self.bt1 = 0
self.bt2 = 0
self.start_time = None
async def start_game(self):
print(f"- Game #{self.game_id} STARTED")
self.game_loop_task = asyncio.create_task(self.game_loop())
self.start_time = datetime.now()
print(f" Begin MATCH at: {self.start_time}")
async def game_loop(self):
print(" In the game loop..")
x = 0
while not self.ended:
if self.botgame:
x += 1
if x == 60:
await self.update_bot_position()
x = 0
await self.handle_pad_movement()
await self.update_game_state()
await self.send_game_state()
await asyncio.sleep(1/60) # Around 60 FPS
async def update_bot_position(self):
future_ball_position = self.predict_ball_trajectory()
target_y = future_ball_position['y']
player2_position = self.game_state['player2_position']
# Adjusts bot position based on expected ball position
if player2_position < target_y < player2_position + 80:
pass #bot already placed
elif player2_position < target_y:
self.game_state['player2_position'] = min(player2_position + (50 * self.speed), 300)
elif player2_position + 80 > target_y:
self.game_state['player2_position'] = max(player2_position - (50 * self.speed), 0)
def predict_ball_trajectory(self, steps=60):
future_x = self.game_state['ball_position']['x']
future_y = self.game_state['ball_position']['y']
velocity_x = self.game_state['ball_velocity']['x']
velocity_y = self.game_state['ball_velocity']['y']
for _ in range(steps):
future_x += velocity_x
future_y += velocity_y
# Dealing with bounces off walls
if future_y <= 0 or future_y >= 300:
velocity_y = -velocity_y # Reverse the direction of vertical movement
return {'x': future_x, 'y': future_y}
async def update_game_state(self):
if self.ended:
return
# Update ball position
self.game_state['ball_position']['x'] += self.game_state['ball_velocity']['x']
self.game_state['ball_position']['y'] += self.game_state['ball_velocity']['y']
# Check for collisions with top and bottom walls
if self.game_state['ball_position']['y'] <= 10 or self.game_state['ball_position']['y'] >= 390:
self.game_state['ball_velocity']['y'] *= -1
# Check for collisions with paddles
if self.game_state['ball_position']['x'] <= 20 and \
self.game_state['player1_position'] - 10 <= self.game_state['ball_position']['y'] <= self.game_state['player1_position'] + 90:
if self.game_state['ball_velocity']['x'] < 0:
self.game_state['ball_velocity']['x'] *= -1
self.bt1 += 1
self.update_ball_velocity()
elif self.game_state['ball_position']['x'] >= 760 and \
self.game_state['player2_position'] - 10 <= self.game_state['ball_position']['y'] <= self.game_state['player2_position'] + 90:
if self.game_state['ball_velocity']['x'] > 0:
self.game_state['ball_velocity']['x'] *= -1
self.bt2 += 1
self.update_ball_velocity()
# Check if some player won the game
if self.game_state['ball_position']['x'] <= 10:
self.game_state['player2_score'] += 1
if self.game_state['player2_score'] > 2:
self.game_state['game_text'] = f"{self.game_state['player2_name']} WINS!"
await self.send_game_state()
await self.end_game()
self.reset_ball()
elif self.game_state['ball_position']['x'] >= 790:
self.game_state['player1_score'] += 1
if self.game_state['player1_score'] > 2:
self.game_state['game_text'] = f"{self.game_state['player1_name']} WINS!"
await self.send_game_state()
await self.end_game()
self.reset_ball()
def reset_ball(self):
self.game_state['ball_position'] = {'x': 390, 'y': 190}
self.game_state['ball_velocity'] = {'x': random.choice([-5, 5]), 'y': random.choice([-5, 5])}
self.speed = 1
def update_ball_velocity(self):
self.speed += 0.05
if self.speed > 2:
self.speed = 2
self.game_state['ball_velocity']['x'] *= self.speed
if self.game_state['ball_velocity']['x'] < -10:
self.game_state['ball_velocity']['x'] = -10
elif self.game_state['ball_velocity']['x'] > 10:
self.game_state['ball_velocity']['x'] = 10
self.game_state['ball_velocity']['y'] *= self.speed
if self.game_state['ball_velocity']['y'] < -10:
self.game_state['ball_velocity']['y'] = -10
elif self.game_state['ball_velocity']['y'] > 10:
self.game_state['ball_velocity']['y'] = 10
async def send_game_state(self):
if self.ended:
return
message = json.dumps({
'type': 'game_state_update',
'game_state': self.game_state
})
await self.player1.send(message)
if not self.botgame:
if not self.localgame:
await self.player2.send(message)
async def handle_key_press(self, player, key):
if self.ended:
return
if self.localgame:
if key == 'arrowup':
self.p2_mov = -1
elif key == 'arrowdown':
self.p2_mov = 1
elif key == 'w':
self.p1_mov = -1
elif key == 's':
self.p1_mov = 1
elif player == self.player1:
if key == 'arrowup':
self.p1_mov = -1
elif key == 'arrowdown':
self.p1_mov = 1
elif player == self.player2:
if key == 'arrowup':
self.p2_mov = -1
elif key == 'arrowdown':
self.p2_mov = 1
async def handle_pad_movement(self):
if self.ended:
return
if self.p1_mov == -1:
self.game_state['player1_position'] = max(self.game_state['player1_position'] - (5 * self.speed), 0)
elif self.p1_mov == 1:
self.game_state['player1_position'] = min(self.game_state['player1_position'] + (5 * self.speed), 300)
if self.p2_mov == -1:
self.game_state['player2_position'] = max(self.game_state['player2_position'] - (5 * self.speed), 0)
elif self.p2_mov == 1:
self.game_state['player2_position'] = min(self.game_state['player2_position'] + (5 * self.speed), 300)
async def end_game(self, disconnected_player=None):
if not self.ended:
self.ended = True
if self.game_loop_task:
self.game_loop_task.cancel()
print(f"- Game #{self.game_id} ENDED")
end_time = datetime.now()
duration = (end_time - self.start_time).total_seconds() / 60
# Notify that one player left the game
if disconnected_player:
remaining_player = self.player2 if disconnected_player == self.player1 else self.player1
disconnected_name = disconnected_player.user.username
message = json.dumps({
'type': 'player_disconnected',
'player': disconnected_name
})
if not self.botgame:
if not self.localgame:
await remaining_player.send(message)
# Notify both players that the game has ended
end_message = json.dumps({
'type': 'game_ended',
'game_id': self.game_id
})
await self.player1.send(end_message)
if not self.botgame:
if not self.localgame:
await self.player2.send(end_message)
await sync_to_async(handle_game_data)(self.game_state['player1_name'], self.game_state['player2_name'],
self.game_state['player1_score'], self.game_state['player2_score'],
self.bt1, self.bt2, duration, False, None)

View File

@ -1,112 +0,0 @@
# /pong/game/matchmaking.py
import json
import asyncio
from .game import Game
class MatchMaker:
def __init__(self):
self.waiting_players = []
self.active_games = {}
self.matching_task = None
self.timer = 0
self.botgame = False
async def add_player(self, player):
if player not in self.waiting_players:
self.waiting_players.append(player)
print(f"User {player.user.username} joins the WAITING ROOM")
if not self.matching_task or self.matching_task.done():
self.matching_task = asyncio.create_task(self.match_loop())
async def remove_player(self, player):
if player in self.waiting_players:
self.waiting_players.remove(player)
for game in self.active_games.values():
if player in [game.player1, game.player2]:
await game.end_game(disconnected_player=player)
del self.active_games[game.game_id]
break
async def match_loop(self):
while True:
if len(self.waiting_players) >= 2:
player1 = self.waiting_players.pop(0)
player2 = self.waiting_players.pop(0)
print(f"*** MATCH FOUND: {player1.user.username} vs {player2.user.username}")
await self.create_game(player1, player2, False)
else:
await asyncio.sleep(1)
self.timer += 1
# Waiting for more than 30s -> BOT game
if self.timer >= 15 and self.waiting_players:
player1 = self.waiting_players.pop(0)
print(f"*** MATCH FOUND: {player1.user.username} vs BOT")
self.botgame = True
self.timer = 0
await self.create_bot_game(player1)
if not self.waiting_players:
break
async def create_game(self, player1, player2, localgame):
game_id = len(self.active_games) + 1
if localgame:
print(f"- Creating LOCAL game: #{game_id}")
else:
print(f"- Creating MATCH game: #{game_id}")
new_game = Game(game_id, player1, player2, localgame)
self.active_games[game_id] = new_game
await player1.set_game(new_game)
if not localgame:
await player2.set_game(new_game)
await self.notify_players(player1, player2, game_id, localgame)
asyncio.create_task(new_game.start_game())
async def create_bot_game(self, player1):
game_id = len(self.active_games) + 1
print(f"- Creating BOT game: #{game_id}")
new_game = Game(game_id, player1, None, False)
self.active_games[game_id] = new_game
await player1.set_game(new_game)
await self.notify_players(player1, None, game_id, False)
asyncio.create_task(new_game.start_game())
async def notify_players(self, player1, player2, game_id, localgame):
if player2:
await player1.send(json.dumps({
'type': 'game_start',
'game_id': game_id,
'player1': player1.user.username,
'player2': player2.user.username
}))
await player2.send(json.dumps({
'type': 'game_start',
'game_id': game_id,
'player1': player1.user.username,
'player2': player2.user.username
}))
else:
if localgame:
await player1.send(json.dumps({
'type': 'game_start',
'game_id': game_id,
'player1': player1.user.username,
'player2': player1.user2.username
}))
else:
await player1.send(json.dumps({
'type': 'game_start',
'game_id': game_id,
'player1': player1.user.username,
'player2': 'BOT'
}))
async def handle_key_press(self, player, key):
for game in self.active_games.values():
if player in [game.player1, game.player2]:
await game.handle_key_press(player, key)
break
# Instance of the class
match_maker = MatchMaker()

View File

@ -1,60 +0,0 @@
# Generated by Django 5.0.7 on 2024-07-31 16:01
import django.db.models.deletion
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Player',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=100)),
('total_match', models.PositiveSmallIntegerField(default=0)),
('total_win', models.PositiveSmallIntegerField(default=0)),
('p_win', models.DecimalField(blank=True, decimal_places=2, max_digits=5, null=True)),
('m_score_match', models.DecimalField(blank=True, decimal_places=2, max_digits=5, null=True)),
('m_score_adv_match', models.DecimalField(blank=True, decimal_places=2, max_digits=5, null=True)),
('best_score', models.PositiveSmallIntegerField(default=0)),
('m_nbr_ball_touch', models.DecimalField(blank=True, decimal_places=2, max_digits=5, null=True)),
('total_duration', models.DecimalField(blank=True, decimal_places=2, max_digits=7, null=True)),
('m_duration', models.DecimalField(blank=True, decimal_places=2, max_digits=5, null=True)),
('num_participated_tournaments', models.PositiveSmallIntegerField(default=0)),
('num_won_tournaments', models.PositiveSmallIntegerField(default=0)),
],
),
migrations.CreateModel(
name='Tournoi',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('name', models.CharField(max_length=200)),
('nbr_player', models.PositiveSmallIntegerField()),
('date', models.DateField()),
('winner', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, to='game.player')),
],
),
migrations.CreateModel(
name='Match',
fields=[
('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
('score_player1', models.PositiveSmallIntegerField()),
('score_player2', models.PositiveSmallIntegerField()),
('nbr_ball_touch_p1', models.PositiveIntegerField()),
('nbr_ball_touch_p2', models.PositiveIntegerField()),
('duration', models.DecimalField(blank=True, decimal_places=2, max_digits=5, null=True)),
('date', models.DateField(auto_now_add=True)),
('is_tournoi', models.BooleanField()),
('player1', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='match_as_player1', to='game.player')),
('player2', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='match_as_player2', to='game.player')),
('winner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='won_matches', to='game.player')),
('tournoi', models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='matches', to='game.tournoi')),
],
),
]

View File

@ -1,19 +0,0 @@
# Generated by Django 5.1.1 on 2024-09-15 16:40
import django.db.models.deletion
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('game', '0001_initial'),
]
operations = [
migrations.AlterField(
model_name='match',
name='winner',
field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, related_name='won_matches', to='game.player'),
),
]

View File

@ -1,78 +0,0 @@
from django.db import models
from django.contrib.auth.models import User
from django.core.exceptions import ValidationError
import logging
logger = logging.getLogger(__name__)
# Ajout d'un champ auth_token à la classe User
User.add_to_class('auth_token', models.CharField(max_length=100, null=True, blank=True, unique=True))
logger.debug("Ajout du champ auth_token à la classe User")
class Player(models.Model):
name = models.CharField(max_length=100)
total_match = models.PositiveSmallIntegerField(default=0)
total_win = models.PositiveSmallIntegerField(default=0)
p_win = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True)
m_score_match = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True)
m_score_adv_match = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True)
best_score = models.PositiveSmallIntegerField(default=0)
m_nbr_ball_touch = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True)
total_duration = models.DecimalField(max_digits=7, decimal_places=2, null=True, blank=True)
m_duration = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True)
num_participated_tournaments = models.PositiveSmallIntegerField(default=0)
num_won_tournaments = models.PositiveSmallIntegerField(default=0)
def __str__(self):
return self.name
def save(self, *args, **kwargs):
logger.info(f"Saving player: {self.name}")
super().save(*args, **kwargs)
logger.info(f"Player {self.name} saved successfully")
class Tournoi(models.Model):
name = models.CharField(max_length=200)
nbr_player = models.PositiveSmallIntegerField()
date = models.DateField()
winner = models.ForeignKey('Player', on_delete=models.SET_NULL, null=True)
def __str__(self):
return self.name
def save(self, *args, **kwargs):
logger.info(f"Saving tournament: {self.name}")
super().save(*args, **kwargs)
logger.info(f"Tournament {self.name} saved successfully")
class Match(models.Model):
player1 = models.ForeignKey('Player', related_name='match_as_player1', on_delete=models.CASCADE)
player2 = models.ForeignKey('Player', related_name='match_as_player2', on_delete=models.CASCADE)
score_player1 = models.PositiveSmallIntegerField()
score_player2 = models.PositiveSmallIntegerField()
winner = models.ForeignKey('Player', related_name='won_matches', on_delete=models.CASCADE, null=True)
nbr_ball_touch_p1 = models.PositiveIntegerField()
nbr_ball_touch_p2 = models.PositiveIntegerField()
duration = models.DecimalField(max_digits=5, decimal_places=2, null=True, blank=True)
date = models.DateField(auto_now_add=True)
is_tournoi = models.BooleanField()
tournoi = models.ForeignKey('Tournoi', related_name='matches', on_delete=models.SET_NULL, null=True)
def clean(self):
logger.debug(f"Cleaning match: {self.player1.name} vs {self.player2.name}")
if self.score_player1 < 0 or self.score_player2 < 0:
raise ValidationError('Les scores doivent être positifs.')
if self.score_player1 > self.score_player2 and self.winner != self.player1:
raise ValidationError('Le gagnant ne correspond pas aux scores.')
if self.score_player2 > self.score_player1 and self.winner != self.player2:
raise ValidationError('Le gagnant ne correspond pas aux scores.')
super().clean()
def save(self, *args, **kwargs):
logger.info(f"Saving match: {self.player1.name} vs {self.player2.name}")
self.clean()
super().save(*args, **kwargs)
logger.info(f"Match {self.player1.name} vs {self.player2.name} saved successfully")
def __str__(self):
return f"{self.player1.name} vs {self.player2.name}"

View File

@ -1,15 +0,0 @@
# /pong/game/routing.py
from django.urls import re_path
from . import consumers
import logging
logger = logging.getLogger(__name__)
logger.debug("Configuring WebSocket routing patterns")
websocket_urlpatterns = [
re_path(r'ws/game/$', consumers.GameConsumer.as_asgi(), name='game_ws'),
re_path(r'ws/chat/(?P<room_name>\w+)/$', consumers.ChatConsumer.as_asgi()),
]
logger.info("WebSocket routing patterns configured successfully")

View File

@ -1,10 +0,0 @@
<!-- templates/tournament_waiting_room.html -->
<div class="tournament-waiting-room">
<h2>Tournament Waiting Room</h2>
<p>Players currently waiting: {{ players|length }}</p>
<ul>
{% for player in players %}
<li>{{ player }}</li>
{% endfor %}
</ul>
</div>

View File

@ -1,49 +0,0 @@
# /pong/game/tournament.py
import json
from django.template.loader import render_to_string
import logging
logger = logging.getLogger(__name__)
class TournamentMatchMaker:
def __init__(self):
self.waiting_players = []
logger.debug("TournamentMatchMaker initialized with an empty waiting_players list")
async def add_player(self, player):
if player not in self.waiting_players:
self.waiting_players.append(player)
logger.info(f"User {player.user.username} added to the TOURNAMENT WAITING ROOM")
await self.update_waiting_room()
else:
logger.warning(f"User {player.user.username} is already in the TOURNAMENT WAITING ROOM")
async def remove_player(self, player):
if player in self.waiting_players:
self.waiting_players.remove(player)
logger.info(f"User {player.user.username} removed from the TOURNAMENT WAITING ROOM")
await self.update_waiting_room()
else:
logger.warning(f"Attempt to remove non-existent user {player.user.username} from the TOURNAMENT WAITING ROOM")
async def update_waiting_room(self):
logger.debug("Updating TOURNAMENT WAITING ROOM")
html = self.generate_waiting_room_html()
for player in self.waiting_players:
await player.send(json.dumps({
'type': 'update_waiting_room',
'html': html
}))
logger.info("TOURNAMENT WAITING ROOM updated and sent to all players")
def generate_waiting_room_html(self):
logger.debug("Generating TOURNAMENT WAITING ROOM HTML")
context = {
'players': [player.user.username for player in self.waiting_players]
}
html = render_to_string('pong/tournament_waiting_room.html', context)
logger.info("TOURNAMENT WAITING ROOM HTML generated successfully")
return html
# Instance of the class
tournament_match_maker = TournamentMatchMaker()

View File

@ -1,17 +0,0 @@
# /pong/game/urls.py
from django.urls import path, include
from . import views
#from rest_framework.routers import DefaultRouter
from .views import match_list_json, player_list_json, tournoi_list_json
urlpatterns = [
path('', views.index, name='index'),
path('check_user_exists/', views.check_user_exists, name='check_user_exists'),
path('register_user/', views.register_user, name='register_user'),
path('authenticate_user/', views.authenticate_user, name='authenticate_user'),
path('web3/', views.read_data, name='read_data'),
path('api/match_list/', match_list_json, name='match_list_json'),
path('api/player_list/', player_list_json, name='player_list_json'),
path('api/tournoi_list/', tournoi_list_json, name='tournoi_list_json')
]

View File

@ -1,192 +0,0 @@
import logging
from .models import Player, Tournoi, Match
from django.core.exceptions import ValidationError
from django.shortcuts import get_object_or_404
from django.db.models import Max, Sum, F
from datetime import timedelta
from channels.db import database_sync_to_async
logger = logging.getLogger(__name__)
def handle_game_data(p1, p2, s_p1, s_p2, bt_p1, bt_2, dur, is_tournoi, name_tournament):
logger.info(f"Handling game data for players: {p1} vs {p2}")
try:
player_1 = get_or_create_player(p1)
player_2 = get_or_create_player(p2)
logger.debug(f"Players created or retrieved: {player_1}, {player_2}")
create_match(player_1, player_2, s_p1, s_p2, bt_p1, bt_2, dur, is_tournoi, name_tournament)
logger.info("Match created successfully")
update_player_statistics(p1)
update_player_statistics(p2)
logger.info("Player statistics updated")
except Exception as e:
logger.error(f"Error in handle_game_data: {e}")
def get_player_by_name(name):
logger.debug(f"Checking if player exists with name: {name}")
exists = Player.objects.filter(name=name).exists()
logger.debug(f"Player exists: {exists}")
return exists
def get_player(name):
logger.debug(f"Retrieving player with name: {name}")
return Player.objects.get(name=name)
def get_or_create_player(name):
logger.info(f"Getting or creating player with name: {name}")
player_exists = get_player_by_name(name)
if not player_exists:
player = create_player(name)
logger.info(f"Player created: {player}")
return player
else:
player = get_player(name)
logger.info(f"Player retrieved: {player}")
return player
def create_player(
name,
total_match=0,
total_win=0,
p_win=None,
m_score_match=None,
m_score_adv_match=None,
best_score=0,
m_nbr_ball_touch=None,
total_duration=None,
m_duration=None,
num_participated_tournaments=0,
num_won_tournaments=0
):
logger.info(f"Creating player: {name}")
player = Player(
name=name,
total_match=total_match,
total_win=total_win,
p_win=p_win,
m_score_match=m_score_match,
m_score_adv_match=m_score_adv_match,
best_score=best_score,
m_nbr_ball_touch=m_nbr_ball_touch,
total_duration=total_duration,
m_duration=m_duration,
num_participated_tournaments=num_participated_tournaments,
num_won_tournaments=num_won_tournaments
)
player.save()
logger.info(f"Player {name} saved successfully")
return player
def create_tournoi(name, nbr_player, date, winner):
logger.info(f"Creating tournament: {name}")
tournoi = Tournoi(name=name, nbr_player=nbr_player, date=date, winner=winner)
tournoi.save()
logger.info(f"Tournament {name} saved successfully")
return tournoi
def create_match(player1, player2, score_player1, score_player2, nbr_ball_touch_p1, nbr_ball_touch_p2, duration, is_tournoi, tournoi):
logger.info(f"Creating match between {player1.name} and {player2.name}")
match = Match(
player1=player1,
player2=player2,
score_player1=score_player1,
score_player2=score_player2,
nbr_ball_touch_p1=nbr_ball_touch_p1,
nbr_ball_touch_p2=nbr_ball_touch_p2,
duration=duration,
is_tournoi=is_tournoi,
tournoi=tournoi
)
if score_player1 > score_player2:
match.winner = match.player1
elif score_player2 > score_player1:
match.winner = match.player2
else:
match.winner = None
match.save()
logger.info(f"Match saved successfully with winner: {match.winner.name if match.winner else 'None'}")
return match
def update_player_statistics(player_name):
logger.info(f"Updating statistics for player: {player_name}")
player = get_object_or_404(Player, name=player_name)
matches_as_player1 = Match.objects.filter(player1=player)
matches_as_player2 = Match.objects.filter(player2=player)
total_match = matches_as_player1.count() + matches_as_player2.count()
if total_match == 0:
logger.warning(f"No matches found for player: {player_name}")
player.total_match = total_match
player.total_win = 0
player.p_win = 0
player.m_score_match = 0
player.m_score_adv_match = 0
player.best_score = 0
player.m_nbr_ball_touch = 0
player.total_duration = 0
player.m_duration = 0
player.num_participated_tournaments = 0
player.num_won_tournaments = 0
player.save()
logger.info(f"Player statistics reset for {player_name}")
return
won_matches = Match.objects.filter(winner=player)
#part_tourn_as_p1 = Tournoi.objects.filter(matches__is_tournoi=True, matches__matches_as_player1=player)
#part_tourn_as_p2 = Tournoi.objects.filter(matches__is_tournoi=True, matches__matches_as_player2=player)
#won_tourn = Tournoi.objects.filter(winner=player)
total_score = matches_as_player1.aggregate(Sum('score_player1'))['score_player1__sum'] or 0
total_score += matches_as_player2.aggregate(Sum('score_player2'))['score_player2__sum'] or 0
total_score_adv = matches_as_player1.aggregate(Sum('score_player2'))['score_player2__sum'] or 0
total_score_adv += matches_as_player2.aggregate(Sum('score_player1'))['score_player1__sum'] or 0
total_win = won_matches.count()
p_win = (total_win / total_match) * 100
m_score_match = total_score / total_match
m_score_adv_match = total_score_adv / total_match
nbr_ball_touch = matches_as_player1.aggregate(Sum('nbr_ball_touch_p1'))['nbr_ball_touch_p1__sum'] or 0
nbr_ball_touch += matches_as_player2.aggregate(Sum('nbr_ball_touch_p2'))['nbr_ball_touch_p2__sum'] or 0
m_nbr_ball_touch = nbr_ball_touch / total_match
total_duration = matches_as_player1.aggregate(Sum('duration'))['duration__sum'] or 0
total_duration += matches_as_player2.aggregate(Sum('duration'))['duration__sum'] or 0
m_duration = total_duration / total_match
#total_tourn_p = part_tourn_as_p1.count() + part_tourn_as_p2.count()
#total_win_tourn = won_tourn.count()
#p_win_tourn = (total_win_tourn / total_tourn_p) * 100 if total_tourn_p else 0
best_score_as_player1 = matches_as_player1.aggregate(Max('score_player1'))['score_player1__max'] or 0
best_score_as_player2 = matches_as_player2.aggregate(Max('score_player2'))['score_player2__max'] or 0
best_score = max(best_score_as_player1, best_score_as_player2)
player.total_match = total_match
player.total_win = total_win
player.p_win = p_win
player.m_score_match = m_score_match
player.m_score_adv_match = m_score_adv_match
player.best_score = best_score
player.m_nbr_ball_touch = m_nbr_ball_touch
player.total_duration = total_duration
player.m_duration = m_duration
# player.num_participated_tournaments = total_tourn_p
#player.num_won_tournaments = total_win_tourn
player.save()
logger.info(f"Statistics updated for player: {player_name}")
def get_player_p_win(player_name):
logger.debug(f"Getting win percentage for player: {player_name}")
player = get_object_or_404(Player, name=player_name)
return player.p_win

View File

@ -1,228 +0,0 @@
# /pong/game/views.py
from django.shortcuts import render
from django.core.exceptions import ObjectDoesNotExist
from .models import Player, Tournoi, Match
from .utils import create_player, create_tournoi, create_match
from django.http import JsonResponse
from django.contrib.auth.models import User
from django.contrib.auth import authenticate
from django.views.decorators.csrf import csrf_exempt
from rest_framework import viewsets
from django.db import transaction, IntegrityError
import json
import uuid
import logging
logger = logging.getLogger(__name__)
def index(request):
logger.info("Accessing index view")
return render(request, 'index.html')
@csrf_exempt
def check_user_exists(request):
if request.method == 'POST':
logger.info("POST request received for checking user existence")
data = json.loads(request.body)
username = data.get('username')
if User.objects.filter(username=username).exists():
logger.info(f"User {username} exists")
return JsonResponse({'exists': True})
logger.info(f"User {username} does not exist")
return JsonResponse({'exists': False})
logger.warning("Invalid request method for check_user_exists")
return JsonResponse({'error': 'Invalid request method'}, status=400)
@csrf_exempt
def register_user(request):
if request.method == 'POST':
try:
logger.info("Received POST request for user registration")
data = json.loads(request.body)
username = data.get('username')
password = data.get('password')
logger.info(f"Attempting to register user: {username}")
if not username or not password:
logger.warning("Username or password not provided")
return JsonResponse({'registered': False, 'error': 'Username and password are required'}, status=400)
with transaction.atomic():
user_exists = User.objects.select_for_update().filter(username=username).exists()
if user_exists:
logger.warning(f"User {username} already exists")
return JsonResponse({'registered': False, 'error': 'User already exists'}, status=409)
user = User.objects.create_user(username=username, password=password)
token = get_or_create_token(user)
logger.info(f"User {username} registered successfully")
return JsonResponse({'registered': True, 'token': token})
except json.JSONDecodeError as e:
logger.error(f"JSON decode error: {str(e)}")
return JsonResponse({'error': 'Invalid JSON data'}, status=400)
except IntegrityError:
logger.error(f"IntegrityError: User {username} already exists")
return JsonResponse({'registered': False, 'error': 'User already exists'}, status=409)
except Exception as e:
logger.error(f"Error in register_user: {str(e)}")
return JsonResponse({'error': f'Internal Server Error: {str(e)}'}, status=500)
logger.warning("Invalid request method for register_user")
return JsonResponse({'error': 'Invalid request method'}, status=405)
def get_or_create_token(user):
logger.info(f"Generating or retrieving token for user: {user.username}")
if not user.auth_token:
while True:
token = str(uuid.uuid4())
if not User.objects.filter(auth_token=token).exists():
user.auth_token = token
user.save()
logger.info(f"Token generated for user {user.username}: {token}")
break
return user.auth_token
@csrf_exempt
def authenticate_user(request):
if request.method == 'POST':
try:
logger.info("Received POST request for user authentication")
data = json.loads(request.body)
username = data.get('username', '')
password = data.get('password', '')
user = authenticate(username=username, password=password)
if user is not None:
token = get_or_create_token(user)
logger.info(f"User {username} authenticated successfully")
return JsonResponse({'authenticated': True, 'token': token, 'user_id': user.id})
else:
logger.warning(f"Authentication failed for user {username}")
return JsonResponse({'authenticated': False}, status=401)
except Exception as e:
logger.error(f"Error in authenticate_user: {str(e)}")
return JsonResponse({'error': str(e)}, status=500)
else:
logger.warning("Invalid request method for authenticate_user")
return JsonResponse({'error': 'Method not allowed'}, status=405)
def match_list_json(request):
logger.info("Fetching match list")
matches = Match.objects.all()
data = {
'matches': list(matches.values(
'id', 'player1__name', 'player2__name', 'score_player1', 'score_player2',
'winner__name', 'nbr_ball_touch_p1', 'nbr_ball_touch_p2', 'duration', 'date',
'is_tournoi', 'tournoi__name'
))
}
logger.info(f"Match list fetched successfully: {len(data['matches'])} matches found")
return JsonResponse(data)
def player_list_json(request):
logger.info("Fetching player list")
players = Player.objects.all()
data = {
'players': list(players.values(
'id', 'name', 'total_match', 'total_win', 'p_win',
'm_score_match', 'm_score_adv_match', 'best_score',
'm_nbr_ball_touch', 'total_duration', 'm_duration',
'num_participated_tournaments', 'num_won_tournaments'
))
}
logger.info(f"Player list fetched successfully: {len(data['players'])} players found")
return JsonResponse(data)
def tournoi_list_json(request):
logger.info("Fetching tournoi list")
tournois = Tournoi.objects.all()
data = {
'tournois': list(tournois.values(
'id', 'name', 'nbr_player', 'date', 'winner'
))
}
logger.info(f"Tournoi list fetched successfully: {len(data['tournois'])} tournois found")
return JsonResponse(data)
def tournoi_list_json(request):
tournois = Tournoi.objects.all()
data = {
'tournois': list(tournois.values(
'id', 'name', 'nbr_player', 'date', 'winner'
))
}
return JsonResponse(data)
from web3 import Web3
provider = Web3.HTTPProvider("https://sepolia.infura.io/v3/60e51df7c97c4f4c8ab41605a4eb9907")
web3 = Web3(provider)
eth_gas_price = web3.eth.gas_price/1000000000
print(eth_gas_price)
contract_address = "0x078D04Eb6fb97Cd863361FC86000647DC876441B"
contract_abi = [{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"uint256","name":"_timecode","type":"uint256"},{"internalType":"uint256","name":"_participantCount","type":"uint256"},{"internalType":"string[]","name":"_playerPseudonyms","type":"string[]"},{"internalType":"string[]","name":"_finalOrder","type":"string[]"}],"name":"addTournament","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getAllTournaments","outputs":[{"components":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"string","name":"name","type":"string"},{"internalType":"uint256","name":"timecode","type":"uint256"},{"internalType":"uint256","name":"participantCount","type":"uint256"},{"internalType":"string[]","name":"playerPseudonyms","type":"string[]"},{"internalType":"string[]","name":"finalOrder","type":"string[]"}],"internalType":"struct PongTournament.Tournament[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"getTournament","outputs":[{"components":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"string","name":"name","type":"string"},{"internalType":"uint256","name":"timecode","type":"uint256"},{"internalType":"uint256","name":"participantCount","type":"uint256"},{"internalType":"string[]","name":"playerPseudonyms","type":"string[]"},{"internalType":"string[]","name":"finalOrder","type":"string[]"}],"internalType":"struct PongTournament.Tournament","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tournamentCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tournaments","outputs":[{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"string","name":"name","type":"string"},{"internalType":"uint256","name":"timecode","type":"uint256"},{"internalType":"uint256","name":"participantCount","type":"uint256"}],"stateMutability":"view","type":"function"}]
contract = web3.eth.contract(address=contract_address, abi=contract_abi)
def read_data(request):
# Créer une instance du contrat
# Appeler une fonction du contrat pour obtenir tous les tournois
tournaments = contract.functions.getAllTournaments().call()
# Afficher les résultats
json_data = []
for tournament in tournaments:
tournament_data = []
for item in tournament:
print(f"{item}")
tournament_data.append(item)
json_data.append(tournament_data)
# Retourner le JSON comme réponse HTTP
# print(f"Tournament ID: {tournament[0]}")
# print(f"Name: {tournament[1]}")
# print(f"Timecode: {tournament[2]}")
# print(f"Participant Count: {tournament[3]}")
# print(f"Player Pseudonyms: {', '.join(tournament[4])}")
# print(f"Final Order: {', '.join(tournament[5])}")
print("-----------------------------")
return JsonResponse(json_data, safe=False)
def write_data(request):
# addTournament(string,uint256,uint256,string[],string[])
# # Configuration de la transaction pour la fonction store
# account = "0x66CeBE2A1F7dae0F6AdBAad2c15A56A9121abfEf"
# private_key = "beb16ee3434ec5abec8b799549846cc04443c967b8d3643b943e2e969e7d25be"
# nonce = web3.eth.get_transaction_count(account)
# transaction = contract.functions.addTournament("test",1721830559,6,["aaudeber", "tlorne", "ocassany", "yestello", "jcheca", "toto"],["toto", "jcheca", "yestello", "tlorne", "ocassany", "aaudeber"]).build_transaction({
# 'chainId': 11155111, # ID de la chaîne Sepolia
# 'gas': 2000000,
# 'gasPrice': web3.to_wei(eth_gas_price, 'gwei'),
# 'nonce': nonce
# })
# # Signature de la transaction
# signed_txn = web3.eth.account.sign_transaction(transaction, private_key)
# # Envoi de la transaction
# tx_hash = web3.eth.send_raw_transaction(signed_txn.rawTransaction)
# print("Transaction hash:", web3.to_hex(tx_hash))
# # Attente de la confirmation de la transaction
# tx_receipt = web3.eth.wait_for_transaction_receipt(tx_hash)
# print("Transaction receipt:", tx_receipt)
print("-----------------------------")

View File

@ -1,212 +0,0 @@
# /pong/settings.py
"""
Django settings for pong project.
Generated by 'django-admin startproject' using Django 3.2.
"""
import os
import logging.config
from pathlib import Path
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/3.2/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '12345678'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = ['*']
# Application definition
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'channels',
'pong.game',
'rest_framework'
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]
ROOT_URLCONF = 'pong.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [os.path.join(BASE_DIR, 'pong', 'static')], # Ensure templates are found
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
ASGI_APPLICATION = 'pong.asgi.application'
# Database
# https://docs.djangoproject.com/en/3.2/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': os.getenv('DB_NAME'),
'USER': os.getenv('DB_USER'),
'PASSWORD': os.getenv('DB_PASSWORD'),
'HOST': os.getenv('DB_HOST'),
'PORT': '5432',
}
}
# Password validation
# https://docs.djangoproject.com/en/3.2/ref/settings/#auth-password-validators
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
# Internationalization
# https://docs.djangoproject.com/en/3.2/topics/i18n/
LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'
USE_I18N = True
USE_L10N = True
USE_TZ = True
STATIC_URL = '/static/'
STATICFILES_DIRS = [os.path.join(BASE_DIR, 'pong/static')]
STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')
# Default primary key field type
# https://docs.djangoproject.com/en/3.2/ref/settings/#default-auto-field
DEFAULT_AUTO_FIELD = 'django.db.models.BigAutoField'
# Channels
# Define the channel layers for WebSockets
# Define the channel layers for WebSockets
CHANNEL_LAYERS = {
'default': {
'BACKEND': 'channels.layers.InMemoryChannelLayer',
},
}
LOGGING = {
'version': 1,
'disable_existing_loggers': False,
'formatters': {
'json': {
'()': 'pythonjsonlogger.jsonlogger.JsonFormatter',
'format': '%(asctime)s %(levelname)s %(name)s %(module)s %(process)d %(thread)d %(message)s',
},
'default': {
'format': '[%(asctime)s] %(levelname)s [%(name)s:%(lineno)s] %(message)s',
},
'verbose': {
'format': '[%(asctime)s] %(levelname)s [%(name)s:%(lineno)s] %(message)s [%(process)d:%(thread)d]',
},
'simple': {
'format': '%(levelname)s %(message)s',
},
},
'filters': {
'require_debug_true': {
'()': 'django.utils.log.RequireDebugTrue',
},
'require_debug_false': {
'()': 'django.utils.log.RequireDebugFalse',
},
},
'handlers': {
'file': {
'level': 'INFO',
'class': 'logging.handlers.RotatingFileHandler',
'filename': os.path.join(BASE_DIR, 'logs/django.log'),
'formatter': 'json',
'maxBytes': 1024 * 1024 * 5, # 5 MB
'backupCount': 5,
},
'error_file': {
'level': 'ERROR',
'class': 'logging.handlers.RotatingFileHandler',
'filename': os.path.join(BASE_DIR, 'logs/django_errors.log'),
'formatter': 'json',
'maxBytes': 1024 * 1024 * 5, # 5 MB
'backupCount': 5,
},
'console': {
'level': 'DEBUG',
'class': 'logging.StreamHandler',
'formatter': 'verbose',
'filters': ['require_debug_true'],
},
'mail_admins': {
'level': 'ERROR',
'class': 'django.utils.log.AdminEmailHandler',
'filters': ['require_debug_false'],
},
},
'loggers': {
'django': {
'handlers': ['file', 'console', 'mail_admins'],
'level': 'DEBUG',
'propagate': True,
},
'django.request': {
'handlers': ['error_file', 'mail_admins'],
'level': 'ERROR',
'propagate': False,
},
'django.security': {
'handlers': ['error_file', 'mail_admins'],
'level': 'ERROR',
'propagate': False,
},
},
'root': {
'handlers': ['console', 'file'],
'level': 'INFO',
},
}

View File

@ -1,397 +0,0 @@
document.addEventListener('DOMContentLoaded', () => {
const menuButton = document.querySelector('.burger-menu');
const dropdownMenu = document.getElementById('dropdown-menu');
const playerList = document.getElementById('player-list');
const matchList = document.getElementById('match-list');
const tournoiList = document.getElementById('tournoi-list');
const blockchainList = document.getElementById('blockchain-list');
const logo = document.querySelector('.logo');
menuButton.addEventListener('click', toggleMenu);
function toggleMenu() {
console.log('Menu toggled');
if (dropdownMenu.style.display === "block") {
dropdownMenu.style.display = "none";
hideAllTables();
} else {
dropdownMenu.style.display = "block";
}
}
function hideAllTables(){
if (playerList) playerList.style.display = 'none';
if (matchList) matchList.style.display = 'none';
if (tournoiList) tournoiList.style.display = 'none';
if (blockchainList) blockchainList.style.display = 'none';
logo.style.display = 'block';
}
const links = document.querySelectorAll('#dropdown-menu a');
links.forEach(link => {
link.addEventListener('click', (event) => {
event.preventDefault();
const tableId = link.getAttribute('data-table');
showTable(tableId);
});
});
function showTable(tableId) {
hideAllTables();
logo.style.display = 'none';
if (tableId === 'player-list') {
playerList.style.display = 'block';
fetchPlayers();
} else if (tableId === 'match-list') {
matchList.style.display = 'block';
fetchMatches();
} else if (tableId === 'tournoi-list') {
tournoiList.style.display = 'block';
fetchTournois();
} else if (tableId === 'blockchain-list') {
console.log('Opening external page in a new tab');
window.open('https://sepolia.etherscan.io/address/0x078d04eb6fb97cd863361fc86000647dc876441b', '_blank');
}
if (dropdownMenu) {
dropdownMenu.style.display = 'none';
}
}
function fetchMatches() {
console.log('Fetching matches...');
fetch('/api/match_list/')
.then(response => response.json())
.then(data => {
if (data.matches) {
displayMatches(data.matches);
}
})
.catch(error => console.error('Error fetching match data:', error));
}
function fetchPlayers(){
console.log('Fetching players...');
fetch('/api/player_list/')
.then(response => response.json())
.then(data => {
if (data.players) {
displayPlayers(data.players);
}
})
.catch(error => console.error('Error fetching match data:', error));
}
function fetchTournois(){
console.log('Fetching tournois...');
fetch('/api/tournoi_list/')
.then(response => response.json())
.then(data => {
if (data.tournois) {
displayTournois(data.tournois);
}
})
.catch(error => console.error('Error fetching match data:', error));
}
function displayMatches(matches) {
console.log('Displaying matches:');
const matchListBody = document.querySelector('#match-list tbody');
matchListBody.innerHTML = '';
if (matches.length != 0) {
matches.forEach(match => {
const row = document.createElement('tr');
row.innerHTML = `
<td>${match.id}</td>
<td>${match.player1__name}</td>
<td>${match.player2__name}</td>
<td>${match.score_player1}</td>
<td>${match.score_player2}</td>
<td>${match.winner__name}</td>
<td>${match.nbr_ball_touch_p1}</td>
<td>${match.nbr_ball_touch_p2}</td>
<td>${match.duration}</td>
<td>${match.date}</td>
<td>${match.is_tournoi}</td>
<td>${match.tournoi__name}</td>
`;
matchListBody.appendChild(row);
});
} else {
row.innerHTML = `
<td colspan="12">No matches found.</td>
`;
matchListBody.appendChild(row);
}
}
function displayPlayers(players) {
console.log('Displaying players:');
const playersListBody = document.querySelector('#player-list tbody');
playersListBody.innerHTML = '';
if (players.length != 0) {
players.forEach(player => {
const row = document.createElement('tr');
row.innerHTML = `
<td>${player.id}</td>
<td>${player.name}</td>
<td>${player.total_match}</td>
<td>${player.total_win}</td>
<td>${player.p_win}</td>
<td>${player.m_score_match}</td>
<td>${player.m_score_adv_match}</td>
<td>${player.best_score}</td>
<td>${player.m_nbr_ball_touch}</td>
<td>${player.total_duration}</td>
<td>${player.m_duration}</td>
<td>${player.num_participated_tournaments}</td>
<td>${player.num_won_tournaments}</td>
`;
playersListBody.appendChild(row);
});
} else {
row.innerHTML = `
<td colspan="12">No matches found.</td>
`
playersListBody.appendChild(row);
}
}
function displayTournois(tournois) {
console.log('Displaying tournois:');
const tournoisListBody = document.querySelector('#tournoi-list tbody');
tournoisListBody.innerHTML = '';
if (tournois.length != 0) {
tournois.forEach(tournoi => {
const row = document.createElement('tr');
row.innerHTML = `
<td>${tournoi.id}</td>
<td>${tournoi.name}</td>
<td>${tournoi.nbr_player}</td>
<td>${tournoi.date}</td>
<td>${tournoi.winner.name}</td>
`;
tournoisListBody.appendChild(row);
});
} else {
row.innerHTML = `
<td colspan="12">No matches found.</td>
`
tournoisListBody.appendChild(row);
}
}
document.getElementById('search-player').addEventListener('input', filterPlayers);
document.getElementById('search-match-player').addEventListener('input', filterMatches);
document.getElementById('search-match-date').addEventListener('input', filterMatches);
function filterPlayers() {
const searchValue = document.getElementById('search-player').value.toLowerCase();
const playersListBody = document.querySelector('#player-list tbody');
const rows = playersListBody.getElementsByTagName('tr');
for (let i = 0; i < rows.length; i++) {
const nameCell = rows[i].getElementsByTagName('td')[1];
if (nameCell) {
const nameValue = nameCell.textContent || nameCell.innerText;
if (nameValue.toLowerCase().indexOf(searchValue) > -1 ) {
rows[i].style.display = '';
} else {
rows[i].style.display = 'none';
}
}
}
}
function filterMatches() {
const playerSearchValue = document.getElementById('search-match-player').value.toLowerCase();
const dateSearchValue = document.getElementById('search-match-date').value;
const matchListBody = document.querySelector('#match-list tbody');
const rows = matchListBody.getElementsByTagName('tr');
for (let i = 0; i < rows.length; i++) {
const player1Cell = rows[i].getElementsByTagName('td')[1];
const player2Cell = rows[i].getElementsByTagName('td')[2];
const dateCell = rows[i].getElementsByTagName('td')[9];
let playerMatch = true;
if (playerSearchValue) {
const player1Value = player1Cell.textContent || player1Cell.innerText;
const player2Value = player2Cell.textContent || player2Cell.innerText;
playerMatch = player1Value.toLowerCase().indexOf(playerSearchValue) > -1 ||
player2Value.toLowerCase().indexOf(playerSearchValue) > -1;
}
let dateMatch = true;
if (dateSearchValue) {
const dateValue = dateCell.textContent || dateCell.innerText;
dateMatch = dateValue.startsWith(dateSearchValue);
}
if (playerMatch && dateMatch) {
rows[i].style.display = '';
} else {
rows[i].style.display = 'none';
}
}
}
document.getElementById('generate-player-chart').addEventListener('click', generatePlayerChart);
document.getElementById('generate-match-chart').addEventListener('click', generateMatchLinePlot);
function generatePlayerChart() {
if (document.getElementById('player-chart').style.display === 'block'){
document.getElementById('player-chart').style.display = 'none';
return ;
}
if (logo.style.display === 'block'){
logo.style.display = 'none';
}
const rows = document.querySelectorAll('#player-list tbody tr');
const playerNames = [];
const totalMatches = [];
const totalWins = [];
rows.forEach(row => {
const cells = row.getElementsByTagName('td');
playerNames.push(cells[1].innerText);
totalMatches.push(parseInt(cells[2].innerText));
totalWins.push(parseInt(cells[3].innerText));
});
const ctx = document.getElementById('player-chart').getContext('2d');
document.getElementById('player-chart').style.display = 'block';
new Chart(ctx, {
type: 'bar',
data: {
labels: playerNames,
datasets: [
{ label: 'Total Matches', data: totalMatches, backgroundColor: 'rgba(75, 192, 192, 0.6)' },
{ label: 'Total Wins', data: totalWins, backgroundColor: 'rgba(54, 162, 235, 0.6)' },
]
},
options: {
scales: {
x: {
ticks: {
color: '#00ffff'
}
},
y: {
beginAtZero: true,
ticks: {
color: '#00ffff'
}
}
}
}
});
}
function generateMatchLinePlot() {
if (document.getElementById('match-chart').style.display === 'block'){
document.getElementById('match-chart').style.display = 'none';
return ;
}
const rows = document.querySelectorAll('#match-list tbody tr');
const playerWins = {};
const dates = [];
rows.forEach(row => {
const cells = row.getElementsByTagName('td');
const winner = cells[5].innerText;
const date = cells[9].innerText;
if (!dates.includes(date)) {
dates.push(date);
}
if (!playerWins[winner]) {
playerWins[winner] = [];
}
let existingEntry = playerWins[winner].find(entry => entry.date === date);
if (existingEntry) {
existingEntry.wins += 1;
}
else {
let lastWinCount = playerWins[winner].length > 0 ? playerWins[winner][playerWins[winner].length - 1].wins : 0;
playerWins[winner].push({ date: date, wins: lastWinCount + 1 });
}
});
const datasets = Object.keys(playerWins).map(player => {
return {
label: player,
data: playerWins[player].map(entry => ({ x: entry.date, y: entry.wins })),
fill: false,
borderColor: getRandomColor(),
tension: 0.1
};
});
const ctx = document.getElementById('match-chart').getContext('2d');
document.getElementById('match-chart').style.display = 'block';
new Chart(ctx, {
type: 'line',
data: {
labels: dates.sort(),
datasets: datasets
},
options: {
scales: {
x: {
type: 'time',
time: {
parser: 'YYYY-MM-DD',
unit: 'day',
tooltipFormat: 'll'
},
title: {
display: true,
text: 'Date'
},
ticks: {
color: '#00ffff'
}
},
y: {
beginAtZero: true,
title: {
display: true,
text: 'Nombre de Victoires Cumulées'
},
ticks: {
color: '#00ffff'
}
}
}
}
});
}
function getRandomColor() {
const letters = '0123456789ABCDEF';
let color = '#';
for (let i = 0; i < 6; i++) {
color += letters[Math.floor(Math.random() * 16)];
}
return color;
}
});

View File

@ -1,7 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1000 1000">
<defs/>
<path id="black_stripe" fill="#000" d="M8,195.25 C178.83,110.03 349.03,140.83 521.26,167.28 C676.47,191.12 833.42,211.85 992,132.75 L992,804.75 C821.17,889.97 650.97,859.17 478.74,832.72 C323.53,808.88 166.58,788.15 8,867.25 L8,195.25"/>
<path id="red_stripe" fill="#D00" d="M8,419.25 C178.83,334.03 349.03,364.83 521.26,391.28 C676.47,415.12 833.42,435.85 992,356.75 L992,804.75 C821.17,889.97 650.97,859.17 478.74,832.72 C323.53,808.88 166.58,788.15 8,867.25 L8,419.25"/>
<path id="gold_stripe" fill="#FFCE00" d="M8,643.25 C178.83,558.03 349.03,588.83 521.26,615.28 C676.47,639.12 833.42,659.85 992,580.75 L992,804.75 C821.17,889.97 650.97,859.17 478.74,832.72 C323.53,808.88 166.58,788.15 8,867.25 L8,643.25"/>
<path fill="#1A1A1A" opacity="0.2" d="M8,195.25 C178.83,110.03 349.03,140.83 521.26,167.28 C676.47,191.12 833.42,211.85 992,132.75 L992,804.75 C821.17,889.97 650.97,859.17 478.74,832.72 C323.53,808.88 166.58,788.15 8,867.25 L8,195.25 M39.25,214.64 L39.25,819.14 C345.81,690.88 650.43,915.18 960.75,785.36 L960.75,180.86 C654.19,309.12 349.57,84.82 39.25,214.64"/>
</svg>

Before

Width:  |  Height:  |  Size: 1.1 KiB

File diff suppressed because one or more lines are too long

Before

Width:  |  Height:  |  Size: 415 KiB

View File

@ -1,7 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1000 1000">
<defs/>
<path fill="#ED2939" d="M8,195.25 C178.83,110.03 349.03,140.83 521.26,167.28 C676.47,191.12 833.42,211.85 992,132.75 L992,804.75 C821.17,889.97 650.97,859.17 478.74,832.72 C323.53,808.88 166.58,788.15 8,867.25 L8,195.25"/>
<path fill="#fff" d="M8,195.25 C225.32,86.83 440.27,166.96 664,185.41 L664,857.41 C448.6,839.65 229.72,756.65 8,867.25 L8,195.25"/>
<path fill="#002395" d="M8,195.25 C116.32,141.21 224.41,133.48 336,142.59 L336,814.59 C227.91,805.77 119.34,811.71 8,867.25 L8,195.25"/>
<path fill="#1A1A1A" opacity="0.2" d="M8,195.25 C178.83,110.03 349.03,140.83 521.26,167.28 C676.47,191.12 833.42,211.85 992,132.75 L992,804.75 C821.17,889.97 650.97,859.17 478.74,832.72 C323.53,808.88 166.58,788.15 8,867.25 L8,195.25 M39.25,214.64 L39.25,819.14 C345.81,690.88 650.43,915.18 960.75,785.36 L960.75,180.86 C654.19,309.12 349.57,84.82 39.25,214.64"/>
</svg>

Before

Width:  |  Height:  |  Size: 946 B

View File

@ -1,7 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1000 1000">
<defs/>
<path fill="#009246" d="M8,195.25 C178.83,110.03 349.03,140.83 521.26,167.28 C676.47,191.12 833.42,211.85 992,132.75 L992,804.75 C821.17,889.97 650.97,859.17 478.74,832.72 C323.53,808.88 166.58,788.15 8,867.25 L8,195.25"/>
<path fill="#fff" d="M336,142.59 C551.4,160.35 770.28,243.35 992,132.75 L992,804.75 C774.68,913.17 559.73,833.04 336,814.59 L336,142.59"/>
<path fill="#ce2b37" d="M664,185.41 C772.09,194.23 880.66,188.29 992,132.75 L992,804.75 C883.68,858.79 775.59,866.52 664,857.41 L664,185.41"/>
<path fill="#1A1A1A" opacity="0.2" d="M8,195.25 C178.83,110.03 349.03,140.83 521.26,167.28 C676.47,191.12 833.42,211.85 992,132.75 L992,804.75 C821.17,889.97 650.97,859.17 478.74,832.72 C323.53,808.88 166.58,788.15 8,867.25 L8,195.25 M39.25,214.64 L39.25,819.14 C345.81,690.88 650.43,915.18 960.75,785.36 L960.75,180.86 C654.19,309.12 349.57,84.82 39.25,214.64"/>
</svg>

Before

Width:  |  Height:  |  Size: 959 B

View File

@ -1,57 +0,0 @@
<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1000 1000">
<defs/>
<path fill="#b22234" d="M8,195.25 C178.83,110.03 349.03,140.83 521.26,167.28 C676.47,191.12 833.42,211.85 992,132.75 L992,804.75 C821.17,889.97 650.97,859.17 478.74,832.72 C323.53,808.88 166.58,788.15 8,867.25 L8,195.25"/>
<path fill="#fff" d="M8,246.94 C178.83,161.72 349.03,192.52 521.26,218.97 C676.47,242.82 833.42,263.54 992,184.44 L992,236.13 C821.17,321.36 650.97,290.56 478.74,264.1 C323.53,240.26 166.58,219.53 8,298.63 L8,246.94 M992,339.52 C821.17,424.74 650.97,393.94 478.74,367.49 C323.53,343.65 166.58,322.92 8,402.02 L8,350.33 C178.83,265.1 349.03,295.91 521.26,322.36 C676.47,346.2 833.42,366.93 992,287.83 L992,339.52 M8,453.71 C178.83,368.49 349.03,399.29 521.26,425.74 C676.47,449.58 833.42,470.31 992,391.21 L992,442.9 C821.17,528.13 650.97,497.32 478.74,470.87 C323.53,447.03 166.58,426.3 8,505.4 L8,453.71 M992,546.29 C821.17,631.51 650.97,600.71 478.74,574.26 C323.53,550.42 166.58,529.69 8,608.79 L8,557.1 C178.83,471.87 349.03,502.68 521.26,529.13 C676.47,552.97 833.42,573.7 992,494.6 L992,546.29 M8,660.48 C178.83,575.26 349.03,606.06 521.26,632.51 C676.47,656.35 833.42,677.08 992,597.98 L992,649.67 C821.17,734.9 650.97,704.09 478.74,677.64 C323.53,653.8 166.58,633.07 8,712.17 L8,660.48 M992,753.06 C821.17,838.28 650.97,807.48 478.74,781.03 C323.53,757.18 166.58,736.46 8,815.56 L8,763.87 C178.83,678.64 349.03,709.44 521.26,735.9 C676.47,759.74 833.42,780.47 992,701.37 L992,753.06"/>
<path fill="#3c3b6e" d="M8,195.25 C138.03,130.38 267.66,132.43 401.6,149.63 L401.6,511.47 C272,494.84 141.49,490.5 8,557.1 L8,195.25"/>
<path id="s" fill="#fff" d="M40.8,195.75 L50.17,229.37 C42.07,224.93 33.98,220.71 25.64,216.63 C35.65,212.1 45.65,207.94 55.96,204.02 L31.43,237.16 L40.8,195.75"/>
<path fill="#fff" d="M40.8,268.12 L50.17,301.74 C42.07,297.29 33.98,293.08 25.64,289 C35.65,284.47 45.65,280.3 55.96,276.39 L31.43,309.53 L40.8,268.12"/>
<path fill="#fff" d="M40.8,340.49 L50.17,374.11 C42.07,369.66 33.98,365.45 25.64,361.37 C35.65,356.84 45.65,352.67 55.96,348.76 L31.43,381.9 L40.8,340.49"/>
<path fill="#fff" d="M40.8,412.86 L50.17,446.48 C42.07,442.03 33.98,437.82 25.64,433.74 C35.65,429.2 45.65,425.04 55.96,421.13 L31.43,454.27 L40.8,412.86"/>
<path fill="#fff" d="M40.8,485.23 L50.17,518.85 C42.07,514.4 33.98,510.19 25.64,506.11 C35.65,501.57 45.65,497.41 55.96,493.5 L31.43,526.64 L40.8,485.23"/>
<path fill="#fff" d="M73.6,219.6 L82.97,253.95 C74.87,248.88 66.78,244.03 58.44,239.27 C68.45,235.55 78.45,232.18 88.76,229.04 L64.23,260.27 L73.6,219.6"/>
<path fill="#fff" d="M73.6,291.97 L82.97,326.32 C74.87,321.25 66.78,316.4 58.44,311.64 C68.45,307.92 78.45,304.54 88.76,301.41 L64.23,332.64 L73.6,291.97"/>
<path fill="#fff" d="M73.6,364.34 L82.97,398.69 C74.87,393.62 66.78,388.77 58.44,384.01 C68.45,380.29 78.45,376.91 88.76,373.78 L64.23,405.01 L73.6,364.34"/>
<path fill="#fff" d="M73.6,436.71 L82.97,471.06 C74.87,465.99 66.78,461.14 58.44,456.38 C68.45,452.66 78.45,449.28 88.76,446.15 L64.23,477.38 L73.6,436.71"/>
<path fill="#fff" d="M106.4,173.57 L115.77,208.59 C107.67,202.95 99.58,197.5 91.24,192.11 C101.25,189.15 111.25,186.5 121.56,184.09 L97.03,213.55 L106.4,173.57"/>
<path fill="#fff" d="M106.4,245.94 L115.77,280.96 C107.67,275.32 99.58,269.87 91.24,264.48 C101.25,261.52 111.25,258.87 121.56,256.46 L97.03,285.91 L106.4,245.94"/>
<path fill="#fff" d="M106.4,318.31 L115.77,353.33 C107.67,347.69 99.58,342.24 91.24,336.85 C101.25,333.89 111.25,331.24 121.56,328.83 L97.03,358.28 L106.4,318.31"/>
<path fill="#fff" d="M106.4,390.68 L115.77,425.7 C107.67,420.05 99.58,414.61 91.24,409.22 C101.25,406.26 111.25,403.61 121.56,401.2 L97.03,430.65 L106.4,390.68"/>
<path fill="#fff" d="M106.4,463.05 L115.77,498.07 C107.67,492.42 99.58,486.98 91.24,481.59 C101.25,478.63 111.25,475.98 121.56,473.57 L97.03,503.02 L106.4,463.05"/>
<path fill="#fff" d="M139.2,202.2 L148.57,237.84 L124.04,219.7 C134.05,217.44 144.05,215.46 154.36,213.71 L129.83,241.54 L139.2,202.2"/>
<path fill="#fff" d="M139.2,274.57 L148.57,310.21 L124.04,292.07 C134.05,289.81 144.05,287.83 154.36,286.08 L129.83,313.91 L139.2,274.57"/>
<path fill="#fff" d="M139.2,346.94 L148.57,382.58 L124.04,364.44 C134.05,362.17 144.05,360.2 154.36,358.45 L129.83,386.28 L139.2,346.94"/>
<path fill="#fff" d="M139.2,419.3 L148.57,454.95 L124.04,436.81 C134.05,434.54 144.05,432.57 154.36,430.82 L129.83,458.65 L139.2,419.3"/>
<path fill="#fff" d="M172,160.56 L181.37,196.76 L156.84,177.12 C166.85,175.49 176.85,174.12 187.16,172.98 L162.63,199.32 L172,160.56"/>
<path fill="#fff" d="M172,232.92 L181.37,269.13 L156.84,249.48 C166.85,247.85 176.85,246.49 187.16,245.35 L162.63,271.68 L172,232.92"/>
<path fill="#fff" d="M172,305.29 L181.37,341.5 L156.84,321.85 C166.85,320.22 176.85,318.86 187.16,317.72 L162.63,344.05 L172,305.29"/>
<path fill="#fff" d="M172,377.66 L181.37,413.87 L156.84,394.22 C166.85,392.59 176.85,391.23 187.16,390.09 L162.63,416.42 L172,377.66"/>
<path fill="#fff" d="M172,450.03 L181.37,486.24 L156.84,466.59 C166.85,464.96 176.85,463.6 187.16,462.45 L162.63,488.79 L172,450.03"/>
<path fill="#fff" d="M204.8,193.19 L214.17,229.91 L189.64,208.89 C199.65,207.84 209.65,207.03 219.96,206.43 L195.43,231.43 L204.8,193.19"/>
<path fill="#fff" d="M204.8,265.56 L214.17,302.28 L189.64,281.26 C199.65,280.21 209.65,279.4 219.96,278.8 L195.43,303.8 L204.8,265.56"/>
<path fill="#fff" d="M204.8,337.93 L214.17,374.65 L189.64,353.63 C199.65,352.58 209.65,351.77 219.96,351.17 L195.43,376.17 L204.8,337.93"/>
<path fill="#fff" d="M204.8,410.3 L214.17,447.02 L189.64,426 C199.65,424.95 209.65,424.14 219.96,423.54 L195.43,448.53 L204.8,410.3"/>
<path fill="#fff" d="M237.6,155.18 L246.97,192.35 L222.44,170.11 C232.45,169.58 242.45,169.27 252.76,169.15 L228.23,192.94 L237.6,155.18"/>
<path fill="#fff" d="M237.6,227.55 L246.97,264.72 L222.44,242.48 C232.45,241.95 242.45,241.63 252.76,241.52 L228.23,265.31 L237.6,227.55"/>
<path fill="#fff" d="M237.6,299.92 L246.97,337.09 L222.44,314.85 C232.45,314.32 242.45,314 252.76,313.89 L228.23,337.68 L237.6,299.92"/>
<path fill="#fff" d="M237.6,372.29 L246.97,409.46 L222.44,387.22 C232.45,386.69 242.45,386.37 252.76,386.26 L228.23,410.05 L237.6,372.29"/>
<path fill="#fff" d="M237.6,444.66 L246.97,481.83 L222.44,459.59 C232.45,459.06 242.45,458.74 252.76,458.63 L228.23,482.42 L237.6,444.66"/>
<path fill="#fff" d="M270.4,191.06 L279.77,228.64 L255.24,205.31 C265.25,205.25 275.25,205.37 285.56,205.67 L261.03,228.41 L270.4,191.06"/>
<path fill="#fff" d="M270.4,263.43 L279.77,301 L255.24,277.68 C265.25,277.61 275.25,277.74 285.56,278.04 L261.03,300.78 L270.4,263.43"/>
<path fill="#fff" d="M270.4,335.8 L279.77,373.37 L255.24,350.05 C265.25,349.98 275.25,350.11 285.56,350.41 L261.03,373.15 L270.4,335.8"/>
<path fill="#fff" d="M270.4,408.17 L279.77,445.74 L255.24,422.42 C265.25,422.35 275.25,422.47 285.56,422.78 L261.03,445.52 L270.4,408.17"/>
<path fill="#fff" d="M303.2,155.91 L312.57,193.83 L288.04,169.57 L318.36,171.08 L293.83,192.9 L303.2,155.91"/>
<path fill="#fff" d="M303.2,228.28 L312.57,266.2 L288.04,241.94 L318.36,243.45 L293.83,265.27 L303.2,228.28"/>
<path fill="#fff" d="M303.2,300.65 L312.57,338.57 L288.04,314.31 L318.36,315.82 L293.83,337.64 L303.2,300.65"/>
<path fill="#fff" d="M303.2,373.02 L312.57,410.94 L288.04,386.68 L318.36,388.19 L293.83,410.01 L303.2,373.02"/>
<path fill="#fff" d="M303.2,445.39 L312.57,483.31 L288.04,459.05 L318.36,460.56 L293.83,482.37 L303.2,445.39"/>
<path fill="#fff" d="M336,194.28 L345.37,232.49 L320.84,207.43 L351.16,209.91 L326.63,230.96 L336,194.28"/>
<path fill="#fff" d="M336,266.65 L345.37,304.86 L320.84,279.8 L351.16,282.28 L326.63,303.33 L336,266.65"/>
<path fill="#fff" d="M336,339.02 L345.37,377.23 L320.84,352.17 L351.16,354.65 L326.63,375.69 L336,339.02"/>
<path fill="#fff" d="M336,411.39 L345.37,449.6 L320.84,424.54 L351.16,427.02 L326.63,448.06 L336,411.39"/>
<path fill="#fff" d="M368.8,161.23 L378.17,199.68 L353.64,173.96 L383.96,177.24 L359.43,197.66 L368.8,161.23"/>
<path fill="#fff" d="M368.8,233.6 L378.17,272.05 L353.64,246.33 L383.96,249.61 L359.43,270.02 L368.8,233.6"/>
<path fill="#fff" d="M368.8,305.97 L378.17,344.42 L353.64,318.7 L383.96,321.98 L359.43,342.39 L368.8,305.97"/>
<path fill="#fff" d="M368.8,378.34 L378.17,416.79 L353.64,391.07 L383.96,394.35 L359.43,414.76 L368.8,378.34"/>
<path fill="#fff" d="M368.8,450.71 L378.17,489.16 L353.64,463.44 L383.96,466.72 L359.43,487.13 L368.8,450.71"/>
<path fill="#1A1A1A" opacity="0.2" d="M8,195.25 C178.83,110.03 349.03,140.83 521.26,167.28 C676.47,191.12 833.42,211.85 992,132.75 L992,804.75 C821.17,889.97 650.97,859.17 478.74,832.72 C323.53,808.88 166.58,788.15 8,867.25 L8,195.25 M39.25,214.64 L39.25,819.14 C345.81,690.88 650.43,915.18 960.75,785.36 L960.75,180.86 C654.19,309.12 349.57,84.82 39.25,214.64"/>
</svg>

Before

Width:  |  Height:  |  Size: 8.7 KiB

File diff suppressed because it is too large Load Diff

View File

@ -1,319 +0,0 @@
{% load static %}
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Pong Game</title>
<link rel="stylesheet" type="text/css" href="{% static 'styles.css' %}?v=3">
<div class="logo">
<img src="{% static 'logo-42-perpignan.png' %}" alt="Logo">
</div>
</head>
<body>
<div class="language-switcher">
<img id="lang-fr" src="{% static 'flags/fr.svg' %}" alt="Français">
<img id="lang-en" src="{% static 'flags/us.svg' %}" alt="English">
<img id="lang-it" src="{% static 'flags/it.svg' %}" alt="Italiano">
<img id="lang-es" src="{% static 'flags/es.svg' %}" alt="Español">
<img id="lang-de" src="{% static 'flags/de.svg' %}" alt="Deutsch">
</div>
<div class="background">
<div class="stars" id="stars"></div>
</div>
<div id="pong-elements" style="display: flex;">
<div class="paddle paddle-left"></div>
<div class="paddle paddle-right"></div>
<div class="ball_anim"></div>
</div>
<button id="settings-btn">⚙️ Réglages</button>
<div id="settings-menu" style="display: none;">
<button id="close-settings">✖️</button>
<h2>Reglages</h2>
<label for="color-picker">Couleur:</label>
<input type="color" id="color-picker">
<br>
<label for="font-selector">Police:</label>
<select id="font-selector">
<option value="Arial">Arial</option>
<option value="Verdana">Verdana</option>
<option value="Times New Roman">Times New Roman</option>
<option value="Courier New">Courier New</option>
</select>
<br>
<label for="font-size-slider">Taille:</label>
<input type="range" id="font-size-slider" min="12" max="36" value="16">
</div>
<div class="container" id="block-form">
<h1 id="welcome">BIENVENUE DANS LE PONG 42</h1>
<div class="input-container">
<div id="auth-form">
<label for="nickname" id="label-nickname">Enter your nickname:</label>
<input type="text" id="nickname" name="nickname">
<button id="check-nickname">Check Nickname</button>
</div>
<div id="register-form" style="display: none;">
<label for="password" id="label-password">Enter your password:</label>
<input type="password" id="password" name="password">
<label for="confirm-password" id="label-confirm-password">Confirm your password:</label>
<input type="password" id="confirm-password" name="confirm-password">
<button id="register">Register</button>
</div>
<div id="login-form" style="display: none;">
<label for="login-password" id="label-login-password">Enter your password:</label>
<input type="password" id="login-password" name="login-password">
<button id="login">Login</button>
</div>
<div id="post-form-buttons" style="display: none;">
<button id="local-game">Local Game</button>
<button id="quick-match">Quick Match</button>
<button id="tournament">Tournament</button>
</div>
<div id="auth-form2" style="display: none;">
<label for="nickname" id="label-nickname2">Enter the second player's nickname:</label>
<input type="text" id="nickname2" name="nickname">
<button id="check-nickname2">Check Nickname</button>
</div>
<div id="register-form2" style="display: none;">
<label for="password" id="label-password2">Enter the second player's password:</label>
<input type="password" id="password2" name="password">
<label for="confirm-password" id="label-confirm-password2">Confirm the second player's password:</label>
<input type="password" id="confirm-password2" name="confirm-password">
<button id="register2">Register</button>
</div>
<div id="login-form2" style="display: none;">
<label for="login-password" id="label-login-password2">Enter the second player's password:</label>
<input type="password" id="login-password2" name="login-password">
<button id="login2">Login</button>
</div>
</div>
</div>
<div class="navbar">
<button class="burger-menu"></button>
<div id="dropdown-menu" class="dropdown-content">
<a href="#" data-table="player-list">Players</a>
<a href="#" data-table="match-list">Matches</a>
<a href="#" data-table="tournoi-list">Tournois</a>
<a href="#" data-table="blockchain-list">blockchain</a>
</div>
</div>
<div id="tournament-bracket" style="display: none;"></div>
<div id="game1" style="display: none;">
<div id="player1-name" class="name">Player 1</div>
<div id="player2-name" class="name">Player 2</div>
<div id="game2">
<div id="player1-score" class="score">0</div>
<div id="player2-score" class="score">0</div>
<div id="player1-pad" class="pad"></div>
<div id="player2-pad" class="pad"></div>
<div id="ball"></div>
<div id="game-text" class="gameText"></div>
</div>
</div>
<div id="match-list" class="content-list" style="display: none;">
<h1>Matches</h1>
<input type="text" id="search-match-player" placeholder="Rechercher par nom de joueur">
<input type="date" id="search-match-date">
<table>
<thead>
<tr>
<th>ID</th>
<th>Player 1</th>
<th>Player 2</th>
<th>Score Player 1</th>
<th>Score Player 2</th>
<th>Winner</th>
<th>Ball Touches Player 1</th>
<th>Ball Touches Player 2</th>
<th>Duration</th>
<th>Date</th>
<th>Is Tournament</th>
<th>Tournament</th>
</tr>
</thead>
<tbody>
</tbody>
</table>
<button id="generate-match-chart">Générer le graphique</button>
<canvas id="match-chart" style="display:none;"></canvas>
</div>
<div id="player-list" class="content-list" style="display: none;">
<h1>Players</h1>
<input type="text" id="search-player" placeholder="Rechercher par nom">
<table>
<thead>
<tr>
<th>ID</th>
<th>Name</th>
<th>Total Matches</th>
<th>Total Wins</th>
<th>Win Percentage</th>
<th>Average Match Score</th>
<th>Average Opponent Score</th>
<th>Best Score</th>
<th>Average Ball Touches</th>
<th>Total Duration</th>
<th>Average Duration</th>
<th>Participated Tournaments</th>
<th>Won Tournaments</th>
</tr>
</thead>
<tbody>
</tbody>
</table>
<button id="generate-player-chart">Générer le graphique</button>
<canvas id="player-chart" style="display:none;"></canvas>
</div>
<div id="tournoi-list" class="content-list" style="display: none;">
<h1>Tournois</h1>
<table>
<thead>
<tr>
<th>ID</th>
<th>Name</th>
<th>Nbr_players</th>
<th>Date</th>
<th>Winner</th>
</tr>
</thead>
<tbody>
</tbody>
</table>
</div>
<script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.29.1/moment.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/chartjs-adapter-moment@1.0.0/dist/chartjs-adapter-moment.min.js"></script>
<script src="{% static 'game.js' %}"></script>
<script src="{% static 'burger.js' %}"></script>
<script src="{% static 'language.js' %}"></script>
<div id="chat-controls">
<button id="show-chat">Afficher le Chat</button>
<button id="hide-chat">Masquer le Chat</button>
</div>
<div id="chat-container">
<!-- Conteneur des journaux de chat -->
<div id="chat-log-container">
<div id="chat-log-main_room" class="chat-log" style="display:block;"></div>
<div id="chat-log-tournament" class="chat-log" style="display:none;"></div>
<div id="chat-log-quick_match" class="chat-log" style="display:none;"></div>
</div>
<!-- Entrées de texte et boutons d'envoi pour chaque room -->
<div id="chat-input-container">
<div id="chat-input-main_room" class="chat-input active">
<input type="text" placeholder="Tapez votre message...">
<button id="chat-button-main_room" class="chat-button"></button>
</div>
<div id="chat-input-tournament" class="chat-input">
<input type="text" placeholder="Tapez votre message...">
<button id="chat-button-tournament" class="chat-button"></button>
</div>
<div id="chat-input-quick_match" class="chat-input">
<input type="text" placeholder="Tapez votre message...">
<button id="chat-button-quick_match" class="chat-button"></button>
</div>
</div>
<!-- Conteneur des onglets de room -->
<div id="room-tabs-container">
<div class="room-tab active" data-room="main_room">Main Room</div>
<div class="room-tab" data-room="tournament">Tournament</div>
<div class="room-tab" data-room="quick_match">Quick Match</div>
</div>
</div>
<script>
document.addEventListener('DOMContentLoaded', function() {
const chatContainer = document.getElementById('chat-container');
const showChatButton = document.getElementById('show-chat');
const hideChatButton = document.getElementById('hide-chat');
showChatButton.addEventListener('click', function() {
chatContainer.style.display = 'flex'; // Afficher le conteneur de chat
});
hideChatButton.addEventListener('click', function() {
chatContainer.style.display = 'none'; // Masquer le conteneur de chat
});
const tabs = document.querySelectorAll('.room-tab');
const chatLogs = document.querySelectorAll('.chat-log');
const chatInputs = document.querySelectorAll('.chat-input');
const chatButtons = document.querySelectorAll('.chat-button');
tabs.forEach(tab => {
tab.addEventListener('click', function() {
const roomId = this.dataset.room;
console.log(`Switching to room: ${roomId}`);
// Afficher le journal de chat correspondant
chatLogs.forEach(log => {
if (log.id === `chat-log-${roomId}`) {
log.style.display = 'block';
console.log(`Displaying chat log for: ${roomId}`);
} else {
log.style.display = 'none';
}
});
// Afficher l'entrée de texte correspondante
chatInputs.forEach(input => {
if (input.id === `chat-input-${roomId}`) {
input.classList.add('active');
input.style.display = 'flex';
console.log(`Displaying chat input for: ${roomId}`);
} else {
input.classList.remove('active');
input.style.display = 'none';
}
});
// Afficher le bouton correspondant
chatButtons.forEach(button => {
if (button.id === `chat-button-${roomId}`) {
button.style.display = 'flex';
console.log(`Displaying chat button for: ${roomId}`);
} else {
button.style.display = 'none';
}
});
// Mettre à jour l'onglet actif
tabs.forEach(t => t.classList.remove('active'));
this.classList.add('active');
console.log(`Tab for ${roomId} is now active`);
});
});
});
</script>
<script>
const starsContainer = document.getElementById('stars');
for (let i = 0; i < 500; i++) {
const star = document.createElement('div');
star.className = 'star';
star.style.width = `${Math.random() * 3}px`;
star.style.height = star.style.width;
star.style.left = `${Math.random() * 100}%`;
star.style.top = `${Math.random() * 100}%`;
star.style.animationDuration = `${Math.random() * 2 + 1}s`;
starsContainer.appendChild(star);
}
</script>
</body>
</html>

View File

@ -1,113 +0,0 @@
document.addEventListener('DOMContentLoaded', () => {
const translations = {
fr: {
welcome: "BIENVENUE DANS LE PONG 42",
labelNickname: "Entrez votre surnom:",
labelPassword: "Entrez votre mot de passe:",
labelConfirmPassword: "Confirmez votre mot de passe:",
labelLoginPassword: "Entrez votre mot de passe:"
},
en: {
welcome: "WELCOME TO PONG 42",
labelNickname: "Enter your nickname:",
labelPassword: "Enter your password:",
labelConfirmPassword: "Confirm your password:",
labelLoginPassword: "Enter your password:"
},
it: {
welcome: "BENVENUTO A PONG 42",
labelNickname: "Inserisci il tuo soprannome:",
labelPassword: "Inserisci la tua password:",
labelConfirmPassword: "Conferma la tua password:",
labelLoginPassword: "Inserisci la tua password:"
},
es: {
welcome: "BIENVENIDO A PONG 42",
labelNickname: "Introduce tu apodo:",
labelPassword: "Introduce tu contraseña:",
labelConfirmPassword: "Confirma tu contraseña:",
labelLoginPassword: "Introduce tu contraseña:"
},
de: {
welcome: "WILLKOMMEN BEI PONG 42",
labelNickname: "Geben Sie Ihren Spitznamen ein:",
labelPassword: "Geben Sie Ihr Passwort ein:",
labelConfirmPassword: "Bestätigen Sie Ihr Passwort:",
labelLoginPassword: "Geben Sie Ihr Passwort ein:"
}
};
function setCookie(name, value, days) {
const d = new Date();
d.setTime(d.getTime() + (days*24*60*60*1000));
const expires = "expires=" + d.toUTCString();
document.cookie = name + "=" + value + ";" + expires + ";path=/";
}
function getCookie(name) {
const cname = name + "=";
const decodedCookie = decodeURIComponent(document.cookie);
const ca = decodedCookie.split(';');
for(let i = 0; i < ca.length; i++) {
let c = ca[i];
while (c.charAt(0) === ' ') {
c = c.substring(1);
}
if (c.indexOf(cname) === 0) {
return c.substring(cname.length, c.length);
}
}
return "";
}
function changeLanguage(lang) {
setCookie('preferredLanguage', lang, 365);
document.getElementById('welcome').innerText = translations[lang].welcome;
document.getElementById('label-nickname').innerText = translations[lang].labelNickname;
document.getElementById('label-password').innerText = translations[lang].labelPassword;
document.getElementById('label-confirm-password').innerText = translations[lang].labelConfirmPassword;
document.getElementById('label-login-password').innerText = translations[lang].labelLoginPassword;
}
function setLanguageFromCookie() {
const preferredLanguage = getCookie('preferredLanguage');
if (preferredLanguage && translations[preferredLanguage]) {
changeLanguage(preferredLanguage);
} else {
changeLanguage('fr'); // Default to French if no cookie is found
}
}
document.getElementById('lang-fr').addEventListener('click', () => changeLanguage('fr'));
document.getElementById('lang-en').addEventListener('click', () => changeLanguage('en'));
document.getElementById('lang-it').addEventListener('click', () => changeLanguage('it'));
document.getElementById('lang-es').addEventListener('click', () => changeLanguage('es'));
document.getElementById('lang-de').addEventListener('click', () => changeLanguage('de'));
window.onload = setLanguageFromCookie;
document.getElementById('settings-btn').addEventListener('click', function() {
document.getElementById('settings-menu').style.display = 'block';
});
document.getElementById('close-settings').addEventListener('click', function() {
document.getElementById('settings-menu').style.display = 'none';
});
document.getElementById('color-picker').addEventListener('input', function() {
document.body.style.color = this.value;
document.querySelectorAll('button').forEach(function(button) {
button.style.backgroundColor = this.value;
}, this);
});
document.getElementById('font-selector').addEventListener('change', function() {
document.body.style.fontFamily = this.value;
});
document.getElementById('font-size-slider').addEventListener('input', function() {
document.body.style.fontSize = this.value + 'px';
});
});

Binary file not shown.

Before

Width:  |  Height:  |  Size: 5.8 KiB

View File

@ -1,681 +0,0 @@
/* General styles */
html {
font-family: Arial, sans-serif;
color: #00ffff;
background-color: #0a0a2a;
margin: 0;
padding: 0;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
height: 100%;
overflow: auto;
}
label {
margin: 10px 0 5px;
}
input {
padding: 10px;
margin: 5px 0 20px;
width: 200px;
}
button {
background-color: #00ffff;
color: #000033;
border: none;
padding: 1rem 2rem;
font-size: 1.5rem;
cursor: pointer;
transition: all 0.3s ease;
border-radius: 10px;
margin-top: 1rem;
text-transform: uppercase;
letter-spacing: 2px;
}
button:hover {
background-color: #000033;
color: #00ffff;
box-shadow: 0 0 20px #00ffff;
}
#game1 {
width: 810px;
height: 500px;
position: relative;
background-color: #000;
border: 3px solid #00ffff;
box-shadow: 0 0 30px #00ffff, inset 0 0 20px #00ffff;
overflow: hidden;
display: flex;
justify-content: center;
align-items: center;
}
.name {
font-size: 24px;
position: absolute;
top: 20px;
}
#player1-name {
left: 10px;
/* Adjust player score position */
}
#player2-name {
right: 10px;
/* Adjust bot score position */
}
#game2 {
top: 60px;
width: 800px;
height: 400px;
position: absolute;
background-color: #000;
overflow: hidden;
border: 2px solid white;
/* Add red border */
display: flex;
justify-content: center;
align-items: center;
}
.score {
font-size: 24px;
position: absolute;
top: 10px;
}
#player1-score {
left: 50px;
/* Adjust player score position */
}
#player2-score {
right: 50px;
/* Adjust bot score position */
}
.pad {
width: 10px;
height: 100px;
background-color: #ffffff;
position: absolute;
}
#player1-pad {
left: 10px;
background-color: #00ffff;
border-radius: 10px;
box-shadow: 0 0 15px #00ffff;
}
#player2-pad {
right: 10px;
background-color: #00ffff;
border-radius: 10px;
box-shadow: 0 0 15px #00ffff;
}
#ball {
width: 20px;
height: 20px;
background-color: #00ffff;
border-radius: 50%;
position: absolute;
}
#game-text {
font-size: 64px;
color: #00ffff;
position: absolute;
top: 150px;
}
.logo {
position: absolute;
top: 20px;
left: 20px;
z-index: 20;
}
.logo img {
max-width: 100%;
height: auto;
}
.stars {
position: absolute;
width: 100%;
height: 100%;
}
.star {
position: absolute;
background-color: #ffffff;
border-radius: 50%;
animation: twinkle 2s infinite alternate;
}
.background {
position: fixed;
top: 0;
left: 0;
width: 100%;
height: 100%;
z-index: 0;
pointer-events: none;
}
.pong-elements {
position: absolute;
top: 0;
left: 0;
width: 100%;
height: 100%;
z-index: 5;
pointer-events: none;
}
.paddle {
position: absolute;
width: 20px;
height: 100px;
background-color: #00ffff;
border-radius: 10px;
box-shadow: 0 0 15px #00ffff;
}
.paddle-left {
left: 50px;
animation: paddleMove 5s infinite alternate ease-in-out;
}
.paddle-right {
right: 50px;
animation: paddleMove 4s infinite alternate-reverse ease-in-out;
}
.ball_anim {
position: absolute;
width: 30px;
height: 30px;
background-color: #00ffff;
border-radius: 50%;
box-shadow: 0 0 20px #00ffff;
left: 80px;
top: 50%;
transform-style: preserve-3d;
animation: ballMove 3s linear infinite;
}
@keyframes paddleMove {
0% {
transform: translateY(10vh);
}
100% {
transform: translateY(70vh);
}
}
@keyframes ballMove {
0% {
transform: translateZ(0) scale(1);
}
50% {
transform: translateZ(-500px) scale(0.5);
}
100% {
transform: translateZ(0) scale(1);
}
}
.input-container {
margin-bottom: 2rem;
}
.container {
text-align: center;
background-color: rgba(0, 0, 40, 0.8);
padding: 3rem;
border-radius: 15px;
border: 3px solid #00ffff;
box-shadow: 0 0 30px #00ffff, inset 0 0 20px #00ffff;
position: relative;
z-index: 10;
max-width: 80%;
overflow: auto;
}
.navbar {
position: absolute;
top: 30px;
right: 10px;
padding: 10px;
}
.burger-menu {
font-size: 24px;
background: none;
border: none;
color: #00ffff;
cursor: pointer;
transition: color 0.3s ease;
}
.burger-menu:hover {
color: #ffffff;
}
.dropdown-content {
display: none;
position: absolute;
top: 100%;
right: 0;
margin-top: 10px;
background-color: #1a1a2e;
color: #ffffff;
box-shadow: 0px 8px 16px rgba(0, 0, 0, 0.3);
border-radius: 5px;
z-index: 1;
width: max-content;
}
.dropdown-content.show {
display: block;
}
.dropdown-content a {
color: #ffffff;
padding: 12px 16px;
text-decoration: none;
display: block;
border-bottom: 1px solid rgba(255, 255, 255, 0.2);
transition: background-color 0.3s ease;
}
.dropdown-content a:hover {
background-color: #333;
color: #00ffff;
}
.language-switcher {
position: absolute;
top: 10px;
right: 10px;
display: flex;
gap: 10px;
}
.language-switcher img {
width: 30px;
height: 20px;
cursor: pointer;
}
#settings-btn {
position: fixed;
bottom: 10px;
right: 10px;
cursor: pointer;
z-index: 1000;
border: none;
border-radius: 50%;
padding: 10px;
font-size: 18px;
}
#settings-menu {
position: fixed;
bottom: 50px;
right: 10px;
padding: 20px;
background-color: rgb(66, 63, 63);
border: 1px solid #ccc;
box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
width: 250px;
z-index: 1000;
}
#close-settings {
position: absolute;
top: 10px;
right: 10px;
background: none;
border: none;
cursor: pointer;
font-size: 16px;
}
.modal {
display: none;
position: fixed;
z-index: 1;
left: 0;
top: 0;
width: 100%;
height: 100%;
overflow: auto;
background-color: rgb(0, 0, 0);
background-color: rgba(0, 0, 0, 0.4);
padding-top: 60px;
}
.modal-content {
background-color: #fefefe;
margin: 5% auto;
padding: 20px;
border: 5px solid #888;
width: 80%;
max-height: 70vh;
overflow-y: auto;
}
.close {
color: #aaa;
float: right;
font-size: 28px;
font-weight: bold;
}
.close:hover,
.close:focus {
color: black;
text-decoration: none;
cursor: pointer;
}
pre {
white-space: pre-wrap;
word-wrap: break-word;
}
.tournament-waiting-room {
background-color: rgba(0, 0, 0, 0.6);
padding: 20px;
border-radius: 15px;
color: #00ffff;
width: 50%;
margin: auto;
text-align: center;
box-shadow: 0 0 30px #00ffff, inset 0 0 20px #00ffff;
}
.tournament-waiting-room h2 {
font-family: 'Arial', sans-serif;
font-size: 2em;
margin-bottom: 15px;
text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.7);
}
.tournament-waiting-room p {
font-family: 'Verdana', sans-serif;
font-size: 1.2em;
margin-bottom: 20px;
text-shadow: 1px 1px 3px rgba(0, 0, 0, 0.6);
}
.tournament-waiting-room ul {
list-style-type: none;
padding: 0;
}
body {
color: rgb(0, 255, 255); /* Valeur par défaut */
font-family: Arial, sans-serif;
font-size: 16px;
}
canvas {
max-width: 100%;
height: auto;
margin-top: 20px;
}
#game-controls {
display: flex;
justify-content: center;
gap: 20px;
margin-bottom: 10px;
}
#game-controls button {
background-color: #00ffff;
color: #000033;
border: none;
padding: 1rem 2rem;
font-size: 1rem;
cursor: pointer;
transition: all 0.3s ease;
border-radius: 10px;
text-transform: uppercase;
letter-spacing: 2px;
}
#game-controls button:hover {
background-color: #000033;
color: #00ffff;
box-shadow: 0 0 20px #00ffff;
}
/**************************CHAT*************************************/
@keyframes borderGlow {
0% {
box-shadow: 0 0 30px #00ffff, inset 0 0 20px #00ffff;
}
50% {
box-shadow: 0 0 60px #0099ff, inset 0 0 40px #0099ff;
}
100% {
box-shadow: 0 0 30px #00ffff, inset 0 0 20px #00ffff;
}
}
#chat-container {
display: none; /* Masquer par défaut */
position: fixed;
bottom: 10px;
left: 10px;
width: 300px;
background-color: rgba(0, 0, 0, 0.7); /* Couleur de fond semi-transparente par défaut */
border-radius: 10px;
padding: 10px;
box-shadow: 0 0 30px #00ffff, inset 0 0 20px #00ffff;
z-index: 1000;
box-sizing: border-box;
flex-direction: column;
animation: borderGlow 3s infinite; /* Ajouter l'animation */
transition: background-color 0.3s, transform 0.3s; /* Ajouter des transitions */
}
#chat-container:hover {
background-color: rgba(0, 0, 0, 1); /* Couleur de fond opaque au survol */
transform: scale(1.05); /* Agrandir légèrement au survol */
}
.chat-log {
max-height: 150px;
overflow-y: auto;
margin-bottom: 10px;
box-sizing: border-box;
background-color: transparent;
display: none;
}
.chat-input {
display: flex;
flex-direction: row;
align-items: center;
justify-content: center;
margin-bottom: 5px;
position: relative; /* Assurez-vous que le conteneur parent est positionné */
}
.chat-input.active {
display: flex; /* Afficher uniquement l'élément actif */
}
.chat-input input[type="text"] {
flex: 1;
padding: 5px;
font-size: 13px;
border: none;
border-radius: 5px;
box-sizing: border-box;
height: 28px;
align-items: center;
justify-content: center;
}
.chat-button {
height: 50px;
width: 50px; /* Réduire la taille du bouton */
border: none;
border-radius: 50%;
background: linear-gradient(45deg, #00ffff, #0099ff);
color: #000033;
cursor: pointer;
position: absolute; /* Positionner le bouton de manière absolue */
right: 10px; /* Ajuster la position à droite */
top: 10%; /* Centrer verticalement */
transform: translateY(-50%); /* Centrer verticalement */
display: flex;
align-items: center;
justify-content: center;
text-align: center;
font-size: 20px;
padding: 0;
box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2);
transition: background 0.3s, transform 0.3s;
animation: buttonGlow 3s infinite; /* Ajouter l'animation */
}
.chat-button:hover {
background: linear-gradient(45deg, #0099ff, #00ffff);
transform: translateY(-50%) scale(1.1); /* Agrandir légèrement au survol */
}
.chat-button:active {
transform: translateY(-50%) scale(0.95); /* Réduire légèrement à l'activation */
}
@keyframes buttonGlow {
0% {
box-shadow: 0 0 10px #00ffff, inset 0 0 5px #00ffff;
}
50% {
box-shadow: 0 0 20px #0099ff, inset 0 0 10px #0099ff;
}
100% {
box-shadow: 0 0 10px #00ffff, inset 0 0 5px #00ffff;
}
}
#room-tabs-container {
display: flex;
justify-content: space-between;
margin-top: 5px;
}
.room-tab {
font-size: 14px;
padding: 5px 10px;
margin-right: 5px;
cursor: pointer;
border: 1px solid #00ffff;
background-color: #000033;
color: #00ffff;
border-radius: 5px;
box-sizing: border-box;
opacity: 0.1;
transition: background 0.3s, transform 0.3s; /* Ajouter des transitions */
animation: tabGlow 3s infinite; /* Ajouter l'animation */
}
.room-tab:hover {
background-color: #00ffff;
color: #000033;
transform: scale(1.1); /* Agrandir légèrement au survol */
}
.room-tab:active {
transform: scale(0.95); /* Réduire légèrement à l'activation */
}
.room-tab.active {
background-color: #00ffff;
color: #000033;
opacity: 1;
}
@keyframes tabGlow {
0% {
box-shadow: 0 0 10px #00ffff, inset 0 0 5px #00ffff;
}
50% {
box-shadow: 0 0 20px #0099ff, inset 0 0 10px #0099ff;
}
100% {
box-shadow: 0 0 10px #00ffff, inset 0 0 5px #00ffff;
}
}
#chat-controls {
position: fixed;
bottom: 10px;
left: 320px; /* Ajuster la position à côté du conteneur de chat */
display: flex;
flex-direction: column;
gap: 5px; /* Espacement entre les boutons */
}
#chat-controls button {
width: 100px; /* Réduire la taille des boutons */
height: 30px; /* Réduire la taille des boutons */
font-size: 12px; /* Ajuster la taille de la police */
padding: 5px;
border-radius: 5px;
cursor: pointer;
background-color: #00ffff;
color: #000033;
border: none;
transition: background-color 0.3s, transform 0.3s;
animation: buttonGlow 3s infinite; /* Ajouter l'animation */
}
#chat-controls button:hover {
background-color: #0099ff;
transform: scale(1.05);
}
#chat-controls button:active {
transform: scale(0.95);
}
@keyframes buttonGlow {
0% {
box-shadow: 0 0 10px #00ffff, inset 0 0 5px #00ffff;
}
50% {
box-shadow: 0 0 20px #0099ff, inset 0 0 10px #0099ff;
}
100% {
box-shadow: 0 0 10px #00ffff, inset 0 0 5px #00ffff;
}
}

View File

@ -1,16 +0,0 @@
# /pong/urls.py
from django.contrib import admin
from django.urls import path, include
from django.conf import settings
from django.conf.urls.static import static
urlpatterns = [
# Disable the admin page
# path('admin/', admin.site.urls),
# path('api/', include('pong.game.urls')),
path('', include('pong.game.urls')),
]
if settings.DEBUG:
urlpatterns += static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)

View File

@ -1,8 +0,0 @@
django
psycopg2
python-dotenv
channels
daphne
djangorestframework
web3
python-json-logger==2.0.7