Merge pull request #13 from udayaKavinda/main

last one before login

.cph/.Lexicographically_smallest_game.py_c217d18353d9d864553049f224fa305c.prob

@@ -0,0 +1 @@
+{"name":"Lexicographically smallest game","group":"HackerRank - ACES PreCoders v8.0","url":"https://www.hackerrank.com/contests/aces-precoders-v8-0/challenges/lexicographically-smallest-game","interactive":false,"memoryLimit":512,"timeLimit":4000,"tests":[{"id":1705139860749,"input":"7\nCAB\nJAM\nCODE\nABAAB\nCABCBBABC\nABCABCABC\nZXCASDQWE","output":"ACB\nAJM\nCODE\nAAABB\nAACBCBBBC\nAAABCBCBC\nACXZSDQWE"}],"testType":"single","input":{"type":"stdin"},"output":{"type":"stdout"},"languages":{"java":{"mainClass":"Main","taskClass":"LexicographicallySmallestGame"}},"batch":{"id":"fb75a126-7b83-471a-8c60-d356359f6b03","size":1},"srcPath":"d:\\Codes\\e19-3yp-Smart-Chessboard\\Lexicographically_smallest_game.py"}

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "cmake.sourceDirectory": "D:/Codes/e19-3yp-Smart-Chessboard/code/smartchessboard/linux"
+}

Lexicographically_smallest_game.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+import ctypes
+
+class ReservedMemory():
+    def __init__(self, size: int) -> None:
+        if not isinstance(size, int):
+            raise TypeError('Memory size must be a positive integer > 0!')
+        if not 1 <= size <= 65536:
+            raise ValueError('Reserved memory size must be between 1 and 65536 bytes!')
+
+        self._reserved_memory = ctypes.create_string_buffer(size)
+
+    def __len__(self) -> int:
+        return len(self._reserved_memory)
+
+    def __repr__(self) -> str:
+        l = len(self._reserved_memory)
+        plural = 's' if l > 1 else ''
+        str_repr = f"[{', '.join(str(ord(i)) for i in self._reserved_memory)}]"
+        return f"ReservedMemory ({l} byte{plural}): {str_repr}"
+
+    def copy(self, mem_source: ReservedMemory, count: int = None, source_index: int = 0, destination_index: int = 0) -> None:
+        if not isinstance(mem_source, ReservedMemory):
+            raise TypeError('Source object must be a ReservedMemory object')
+
+        if count is None:
+            count = len(mem_source._reserved_memory) - source_index
+        elif not isinstance(count, int):
+            raise TypeError('Count must be a positive integer > 0')
+        elif count <= 0:
+            raise ValueError('Count must be a positive integer > 0')
+
+        if not isinstance(source_index, int):
+            raise TypeError('Source index must be a positive integer >= 0')
+        elif not 0 <= source_index < len(mem_source._reserved_memory):
+            raise IndexError('Source index out of bounds!')
+
+        if not isinstance(destination_index, int):
+            raise TypeError('Destination index must be a positive integer >= 0')
+        elif not 0 <= destination_index < len(self._reserved_memory):
+            raise IndexError('Destination index out of bounds!')
+
+        if count > len(self._reserved_memory):
+            raise IndexError('Source is bigger than destination!')
+        elif source_index + count > len(mem_source._reserved_memory):
+            raise IndexError('Source copy area out of bounds!')
+        elif destination_index + count > len(self._reserved_memory):
+            raise IndexError('Destination copy area out of bounds!')
+
+        self._reserved_memory[destination_index:destination_index + count] = \
+            mem_source._reserved_memory[source_index:source_index + count]
+
+class IntArray():
+    def __init__(self, bytes_per_element: int = 2) -> None:
+        self._resmem = None
+        self._size = 0
+        self._bytes_per_element = bytes_per_element
+        self._shift_val = 2 ** ((self._bytes_per_element * 8) - 1)
+        self._min_val = -self._shift_val
+        self._max_val = self._shift_val - 1
+
+    def __len__(self) -> int:
+        return self._size
+
+    def __iter__(self):
+        self._iter_index = 0
+        return self
+
+    def __next__(self) -> int:
+        if self._iter_index < self._size:
+            self._iter_index += 1
+            return self.__getitem__(self._iter_index - 1)
+        else:
+            raise StopIteration
+
+    def __repr__(self) -> str:
+        if not self._resmem:
+            return "Empty IntArray"
+        l = self._size
+        plural = 's' if l > 1 else ''
+        str_repr = f"[{', '.join(str(v) for v in self)}]"
+        return f"IntArray ({l} element{plural}): {str_repr}"
+
+    def __setitem__(self, k: int, val: int) -> None:
+        if not isinstance(val, int) or not self._min_val <= val <= self._max_val:
+            raise TypeError(f'Value must be an integer between {self._min_val} and {self._max_val}')
+
+        val_to_store = val + self._shift_val
+
+        for byte_index in range(self._bytes_per_element):
+            self._resmem[k * self._bytes_per_element + byte_index] = (val_to_store >> (8 * byte_index)) & 255
+
+    def __getitem__(self, k: int) -> int:
+        stored_val = 0
+        for byte_index in range(self._bytes_per_element):
+            stored_val |= self._resmem[k * self._bytes_per_element + byte_index] << (8 * byte_index)
+        return (stored_val - self._shift_val)
+
+    def append(self, val: int) -> None:
+        if not isinstance(val, int) or not self._min_val <= val <= self._max_val:
+            raise TypeError(f'Value must be an integer between {self._min_val} and {self._max_val}')
+
+        self._size += 1
+        new_resmem = ReservedMemory(self._size * self._bytes_per_element)
+
+        if self._resmem:
+            new_resmem.copy(self._resmem)
+
+        self._resmem = new_resmem
+        self.__setitem__(self._size - 1, val)
+
+    def pop(self) -> int:
+        if self._size == 0:
+            return None
+
+        val = self.__getitem__(self._size - 1)
+        self._size -= 1
+
+        if self._size > 0:
+            new_resmem = ReservedMemory(self._size * self._bytes_per_element)
+            new_resmem.copy(self._resmem, count=self._size * self._bytes_per_element)
+        else:
+            new_resmem = None
+
+        self._resmem = new_resmem
+
+        return val
+
+    def insert(self, index: int, val: int) -> None:
+        if not isinstance(val, int) or not self._min_val <= val <= self._max_val:
+            raise TypeError(f'Value must be an integer between {self._min_val} and {self._max_val}')
+
+        if not 0 <= index <= self._size:
+            raise IndexError('Index is out of bounds!')
+
+        self._size += 1
+        new_resmem = ReservedMemory(self._size * self._bytes_per_element)
+        new_resmem.copy(self._resmem, count=index * self._bytes_per_element)
+        new_resmem[index * self._bytes_per_element:index * self._bytes_per_element + self._bytes_per_element] = \
+            self._resmem[index * self._bytes_per_element:index * self._bytes_per_element + self._bytes_per_element]
+        new_resmem.copy(self._resmem, count=(self._size - index - 1) * self._bytes_per_element,
+                        source_index=index * self._bytes_per_element,
+                        destination_index=(index + 1) * self._bytes_per_element)
+        self._resmem = new_resmem
+        self.__setitem__(index, val)
+
+array = IntArray()
+array.append(1)
+# array.append(2)
+# array.append(3)
+
+# print(array)  # Output: IntArray (3 elements): [1, 2, 3]
+
+# array.insert(1, 10)
+
+# print(array)

code/server/index.js

@@ -4,6 +4,8 @@ const http = require("http");
 const { mongoose } = require("mongoose");
 const { Socket } = require("socket.io");
 const Room = require("./models/room");
+const { on } = require("events");
+const Eprofile = mongoose.model('Eprofile',require("./models/eprofile"));
 
 const port=process.env.PORT || 3000;
 var server =http.createServer(app);
@@ -13,54 +15,80 @@ var io=require("socket.io")(server);
 app.use(express.json());
 
 // database
-const DB="mongodb+srv://<userName>:<password>@cluster0.jovzlek.mongodb.net/?retryWrites=true&w=majority";
+const DB="mongodb+srv://namal:qazxnmlp@cluster0.jovzlek.mongodb.net/?retryWrites=true&w=majority";
+
 mongoose.connect(DB).then(()=>{
     console.log("DB connection established");
 }).catch(err => console.log(err) );
 //database
 
+const onlinePlayers = [];
+const onlineCommunityPlayers=[];
+let room;
+
 io.on("connection",(socket)=>{
+    console.log("IO connection established");
+    socket.on('init', async ({profileId}) => {
+        try {
+            console.log(profileId);
+            let eprofile =await Eprofile.findOne({"profileId":profileId});
+            if(eprofile){
+                eprofile.socketId=socket.id;
+            }else{
+                eprofile =new Eprofile({"profileId":profileId,"socketId":socket.id});
+                }
+            await eprofile.save();
+            socket.emit('initDone',eprofile);
+        } catch (e) {
+            console.log(e);
+        }
+    });
+
+    socket.on('disconnect', async () => {
+        try {
+            console.log("Disconnect");
+            handleCommunityDisconnect(socket.id);
+            handleGameMenuDisconnect(socket.id);
+            handleGameDisconnect(socket.id);
+
+        } catch (e) {
+            console.log(e);
+        }
+    });
+
+    //game-menu screen
     try{
-        console.log("IO connection established");
         socket.on("createOrJoinRoom",async ()=>{
-        let room =await Room.findOne({isJoin:true});
-        if(room){
+            console.log("onlinegame");
+
+        if(onlinePlayers.length==0){
+            room =new Room();
             const roomId=room._id.toString();
-            room.isJoin = false;
-            let player = {
-                socketID:socket.id,
-                playerType:"Black",
-            }
-            room.players.push(player);
-            room = await room.save();
+            onlinePlayers.push([roomId,socket.id]);
             socket.join(roomId);
-            const roomSockets = io.sockets.adapter.rooms.get(roomId);
-            const allSocketIds = Array.from(roomSockets);
-            const otherSocketId = allSocketIds.find(socketId => socketId !== socket.id);
-            io.to(otherSocketId).emit("joinRoomSuccess",room);
-            room.isWhite=false;
-            io.to(socket.id).emit("joinRoomSuccess",room); 
-            console.log(roomId);
         }else{
-            room =new Room();
-            const roomId=room._id.toString();
-            let player ={
-                socketID:socket.id,
-                playerType:"White",
-            }
-            room.players.push(player);
-            room.isWhite=true;
-            room=await room.save();
+            const [roomId,otherSocketId]=onlinePlayers.pop();
+            if(otherSocketId!=socket.id){
             socket.join(roomId);
-            io.to(roomId).emit("createRoomSuccess",room);
-            console.log(roomId);
+            room.players.push(await Eprofile.findOne({"socketId":socket.id}));
+            room.players.push(await Eprofile.findOne({"socketId":otherSocketId}));
+            room = await room.save();
+            io.to(roomId).emit("joinRoomSuccess",room);
+            console.log(room);
+            }else{
+                onlinePlayers.push([roomId,otherSocketId]);
+            }
         }
         });
         }catch(e){
         console.log(e);
         }
 
+        socket.on('gameMenuDisconnect', async () => {
+            try {handleGameMenuDisconnect(socket.id);} catch (e) {console.log(e);}
+        });
 
+    //game screnn
     socket.on('chessMove', (data) => {
         try{
             console.log(data);
@@ -70,15 +98,65 @@ io.on("connection",(socket)=>{
             console.log(e);
         }
     });
+    socket.on('gameDisconnect', async () => {
+        handleGameDisconnect(socket.id);
+    });
+    socket.on('askCommunityGame', async ({profileId}) => {
+        try {
+            let eprofile =await Eprofile.findOne({"profileId":profileId});
+            console.log(eprofile);
+            io.to(eprofile.socketId).emit('communityGameAcceptorWithdraw', {"profileId":profileId});
+
+        } catch (e) {
+            console.log(e);
+        }
+    });
+
+    //community screen
+    socket.on('communityDisconnect', async () => {
+        try {handleCommunityDisconnect(socket.id);} catch (e) {console.log(e);}
+        let eprofiles = await Eprofile.find({ socketId: { $in: onlineCommunityPlayers } });
+        io.emit('community', eprofiles);
+    });
 
+    socket.on('communityConnect', async () => {
+        try {
+            console.log("communityConnect");
+            onlineCommunityPlayers.push(socket.id);
+            let eprofiles = await Eprofile.find({ socketId: { $in: onlineCommunityPlayers } });
+            io.emit('community', eprofiles);
+        } catch (e) {
+            console.log(e);
+        }
+    });
+
+    function handleGameDisconnect(socketId) {
+        // const rooms = io.sockets.adapter.room;
+
+        // for (const roomId in rooms) {
+        //     console.log("Game disconnected"+rooms.first);
 
-});
+        // }
+    } 
 
+    function handleCommunityDisconnect(socketId) {
+        console.log("Community disconnected"+socketId);
+        const indexToRemove = onlineCommunityPlayers.indexOf(socketId);
+        if (indexToRemove !== -1) {
+            onlineCommunityPlayers.splice(indexToRemove, 1);
+            }
+    }   
 
+    function handleGameMenuDisconnect(socketId) {
+        console.log("Game menu disconnected"+socketId);
+        if(onlinePlayers.length!=0){
+            const [roomId,otherSocketId]=onlinePlayers.pop();
+            if(otherSocketId!=socketId){
+                onlinePlayers.push([roomId,otherSocketId]);
+        }}
+    }
+});
 
-// app.get("/", function(req, res) {
-//     res.send("no"+process.env.PORT);
-// });
 
 server.listen(port, "0.0.0.0", () => {
     console.log("udaya " +port);

code/server/models/eprofile.js

@@ -0,0 +1,18 @@
+const mongoose = require('mongoose');
+const eprofileSchema =new mongoose.Schema({
+    nickname: {
+        type:String,
+        default:"udaya",
+    },
+    profileId: {
+        type:String,
+    },
+    socketId: {
+        type:String, 
+    },
+
+    });
+
+    // const eprofileModel = mongoose.model('Eprofile',eprofileSchema);
+    // module.exports =eprofileModel ;
+    module.exports =eprofileSchema ;