Video Game

1    (?<!^\t)(?<!^\t\t)(?<!^\t\t\t)(?<!^\t\t\t\t)[{}]|[{}](?!\R)
2    Menu "MenuName"
3    {
4        Menu "SubMenuName"
5        {
6            Option "OptionName" "Command"
7            Option "OptionName" "Command"
8        }
9    }
10// This is a comment line
11// [ curly brackets in comment lines are made square so they don't get counted as balancing
12    Menu "MenuName"{
13        Menu "SubMenuName"
14        {
15            Option "OptionName" "Command"
16            Option "OptionName" "Command"   }
17    }Menu "That bracket would be wrong since the line should end afterwards.
18    {   //this would also be wrong
19// Nothing should ever follow a bracket except a End Of Line character.
20//DO NOT DELETE, needs a line here for some reason.
21Menu "MenuNameTEMPLATE"
22{
23    Title "TitleName"
24    Option "OptionName" "Command"
25    Divider
26    LockedOption
27    {
28        DisplayName "OptionName"
29        Command "Command"
30        Icon "IconName"
31        PowerReady "PowerIdentifiers"
32    }
33    LockedOption
34    {
35        DisplayName "OptionName"
36        Command "Command"
37        Icon "IconName"
38        Badge "BadgeIdentifiers"
39    }
40    LockedOption
41    {
42        DisplayName "OptionName"
43        Command "Command"
44        Icon "IconName"
45    }
46    Menu "SubMenuName"
47    {
48        Title "TitleName"
49        Option "OptionName" "Command"
50        Option "OptionName" "Command"
51    }
52}
53^(?:[^{}]*|\t{1,4}[{}])$
54

1// roland@babylonjs.xyz, 2022
2
3const createScene = function () {
4const scene = new BABYLON.Scene(engine);
5
6const camera = new BABYLON.ArcRotateCamera('camera', -Math.PI / 2, Math.PI / 2, 20, new BABYLON.Vector3(0, 0, 0), scene)
7camera.attachControl(canvas, true);
8
9const light = new BABYLON.HemisphericLight("light", new BABYLON.Vector3(0, 1, 0), scene);
10light.intensity = 0.7;
11
12const wall = BABYLON.MeshBuilder.CreateBox('wall', { width: 5, height: 5, depth: 0.5 }, scene)
13wall.position.y = 1
14wall.position.z = -2
15
16const sphere = BABYLON.MeshBuilder.CreateSphere('sphere', { diameter: 2, segments: 32 }, scene)
17sphere.position.y = 1
18
19const sphereClone = sphere.clone('sphereClone')
20sphereClone.setEnabled(false)
21
22const matc = new BABYLON.StandardMaterial("matc", scene);
23matc.depthFunction = BABYLON.Constants.ALWAYS;
24matc.disableColorWrite = true;
25matc.disableDepthWrite = true;
26
27sphereClone.material = matc;
28
29sphere.occlusionQueryAlgorithmType = BABYLON.AbstractMesh.OCCLUSION_ALGORITHM_TYPE_ACCURATE
30sphere.occlusionType = BABYLON.AbstractMesh.OCCLUSION_TYPE_STRICT
31
32const hl = new BABYLON.HighlightLayer('hl1', scene, { camera: camera })
33hl.addMesh(sphereClone, BABYLON.Color3.Green())
34hl.addExcludedMesh(wall);
35
36let t = 0;
37
38scene.onBeforeRenderObservable.add(() => {
39    sphere.position.x = 10 * Math.cos(t);
40    sphere.position.z = 100 + 104 * Math.sin(t);
41
42    if (sphere.isOccluded) {
43        sphereClone.setEnabled(true)
44        sphereClone.position.copyFrom(sphere.position);
45    } else {
46        sphereClone.setEnabled(false)
47    }
48
49    t += 0.03;
50})
51
52return scene;
53};
54

1// roland@babylonjs.xyz, 2022
2
3const createScene = function () {
4const scene = new BABYLON.Scene(engine);
5
6const camera = new BABYLON.ArcRotateCamera('camera', -Math.PI / 2, Math.PI / 2, 20, new BABYLON.Vector3(0, 0, 0), scene)
7camera.attachControl(canvas, true);
8
9const light = new BABYLON.HemisphericLight("light", new BABYLON.Vector3(0, 1, 0), scene);
10light.intensity = 0.7;
11
12const wall = BABYLON.MeshBuilder.CreateBox('wall', { width: 5, height: 5, depth: 0.5 }, scene)
13wall.position.y = 1
14wall.position.z = -2
15
16const sphere = BABYLON.MeshBuilder.CreateSphere('sphere', { diameter: 2, segments: 32 }, scene)
17sphere.position.y = 1
18
19const sphereClone = sphere.clone('sphereClone')
20sphereClone.setEnabled(false)
21
22const matc = new BABYLON.StandardMaterial("matc", scene);
23matc.depthFunction = BABYLON.Constants.ALWAYS;
24matc.disableColorWrite = true;
25matc.disableDepthWrite = true;
26
27sphereClone.material = matc;
28
29sphere.occlusionQueryAlgorithmType = BABYLON.AbstractMesh.OCCLUSION_ALGORITHM_TYPE_ACCURATE
30sphere.occlusionType = BABYLON.AbstractMesh.OCCLUSION_TYPE_STRICT
31
32const hl = new BABYLON.HighlightLayer('hl1', scene, { camera: camera })
33hl.addMesh(sphereClone, BABYLON.Color3.Green())
34hl.addExcludedMesh(wall);
35
36let t = 0;
37
38scene.onBeforeRenderObservable.add(() => {
39    sphere.position.x = 10 * Math.cos(t);
40    sphere.position.z = 100 + 104 * Math.sin(t);
41
42    if (sphere.isOccluded) {
43        sphereClone.setEnabled(true)
44        sphereClone.position.copyFrom(sphere.position);
45    } else {
46        sphereClone.setEnabled(false)
47    }
48
49    t += 0.03;
50})
51
52return scene;
53};
54// roland@babylonjs.xyz, 2022
55
56const createScene = function () {
57const scene = new BABYLON.Scene(engine);
58
59const camera = new BABYLON.ArcRotateCamera('camera', -Math.PI / 2, Math.PI / 2, 20, new BABYLON.Vector3(0, 0, 0), scene)
60camera.attachControl(canvas, true);
61
62const light = new BABYLON.HemisphericLight("light", new BABYLON.Vector3(0, 1, 0), scene);
63light.intensity = 0.7;
64
65const wall = BABYLON.MeshBuilder.CreateBox('wall', { width: 5, height: 5, depth: 0.5 }, scene)
66wall.position.y = 1
67wall.position.z = -2
68
69const sphere = BABYLON.MeshBuilder.CreateSphere('sphere', { diameter: 2, segments: 32 }, scene)
70sphere.position.y = 1
71
72sphere.occlusionQueryAlgorithmType = BABYLON.AbstractMesh.OCCLUSION_ALGORITHM_TYPE_ACCURATE
73sphere.occlusionType = BABYLON.AbstractMesh.OCCLUSION_TYPE_STRICT
74
75const mats = new BABYLON.StandardMaterial("mats", scene);
76sphere.material = mats;
77
78const hl = new BABYLON.HighlightLayer('hl1', scene, { camera: camera })
79hl.addExcludedMesh(wall);
80
81let t = 0;
82
83const cur = BABYLON.AbstractMesh.prototype._checkOcclusionQuery;
84
85scene.onDisposeObservable.add(() => {
86    BABYLON.AbstractMesh.prototype._checkOcclusionQuery = cur;
87});
88
89BABYLON.AbstractMesh.prototype._checkOcclusionQuery = function() {
90    cur.apply(this);
91    return false;
92}
93
94scene.onBeforeRenderObservable.add(() => {
95    sphere.position.x = 10 * Math.cos(t);
96    sphere.position.z = 100 + 104 * Math.sin(t);
97
98    if (sphere.isOccluded) {
99        hl.addMesh(sphere, BABYLON.Color3.Green())
100        mats.depthFunction = BABYLON.Constants.ALWAYS;
101        mats.disableColorWrite = true;
102    } else {
103        hl.removeMesh(sphere);
104        mats.depthFunction = BABYLON.Constants.LESS;
105        mats.disableColorWrite = false;
106    }
107
108    t += 0.03;
109})
110
111return scene;
112};
113

1  const [questions, setQuestions] = useState({});
2  const [index, setIndex] = useState(0);
3  
4  async function handleQuestions() {
5    const fetchQuestions = await fetchTriviaApi();
6    setQuestions(fetchQuestions.results);
7  }
8
9  useEffect(() => {
10    handleQuestions();
11  }, []);
12    (5) [{…}, {…}, {…}, {…}, {…}]
130: {category: 'Entertainment: Music', type: 'boolean', difficulty: 'medium', question: 'Rapper Snoop Dogg's real name is 'Cordozar Calvin Broadus, Jr.'.', correct_answer: 'True', …}
141: {category: 'Entertainment: Video Games', type: 'multiple', difficulty: 'medium', question: 'Which of these "Worms" games featured 3D gameplay?', correct_answer: 'Worms 4: Mayhem', …}
152: {category: 'Vehicles', type: 'multiple', difficulty: 'easy', question: 'What UK Train does NOT go over 125MPH?', correct_answer: 'Sprinter', …}
163: {category: 'Entertainment: Video Games', type: 'boolean', difficulty: 'medium', question: 'Tony Hawk's Pro Skater was released in 1999.', correct_answer: 'True', …}
174: {category: 'Entertainment: Video Games', type: 'boolean', difficulty: 'hard', question: 'In The Witcher 3, the Zoltan Chivay Gwent card can be found under the Hanged Man's Tree.', correct_answer: 'True', …}
18length: 5
19{category: 'Entertainment: Music', type: 'boolean', difficulty: 'medium', question: 'Rapper Snoop Dogg's real name is 'Cordozar Calvin Broadus, Jr.'.', correct_answer: 'True', …}
20const [questions, setQuestions] = useState([]);
21

1  const [questions, setQuestions] = useState({});
2  const [index, setIndex] = useState(0);
3  
4  async function handleQuestions() {
5    const fetchQuestions = await fetchTriviaApi();
6    setQuestions(fetchQuestions.results);
7  }
8
9  useEffect(() => {
10    handleQuestions();
11  }, []);
12    (5) [{…}, {…}, {…}, {…}, {…}]
130: {category: 'Entertainment: Music', type: 'boolean', difficulty: 'medium', question: 'Rapper Snoop Dogg's real name is 'Cordozar Calvin Broadus, Jr.'.', correct_answer: 'True', …}
141: {category: 'Entertainment: Video Games', type: 'multiple', difficulty: 'medium', question: 'Which of these "Worms" games featured 3D gameplay?', correct_answer: 'Worms 4: Mayhem', …}
152: {category: 'Vehicles', type: 'multiple', difficulty: 'easy', question: 'What UK Train does NOT go over 125MPH?', correct_answer: 'Sprinter', …}
163: {category: 'Entertainment: Video Games', type: 'boolean', difficulty: 'medium', question: 'Tony Hawk's Pro Skater was released in 1999.', correct_answer: 'True', …}
174: {category: 'Entertainment: Video Games', type: 'boolean', difficulty: 'hard', question: 'In The Witcher 3, the Zoltan Chivay Gwent card can be found under the Hanged Man's Tree.', correct_answer: 'True', …}
18length: 5
19{category: 'Entertainment: Music', type: 'boolean', difficulty: 'medium', question: 'Rapper Snoop Dogg's real name is 'Cordozar Calvin Broadus, Jr.'.', correct_answer: 'True', …}
20const [questions, setQuestions] = useState([]);
21{questions.length > 0 && questions[index].category}
22

1.half-circle{
2width: 60px; 
3height: 120px; 
4border-radius: 60px 0 0 60px;
5background: #15DEA5;
6}<body>
7
8<div class ="half-circle"></div>
9</body> .half-circle {
10        width: 60px;
11        height: 120px;
12        border-top-left-radius: 110px;
13        border-bottom-left-radius: 110px;
14        border: 10px solid gray;
15        border-right: 0;
16    }
17

1.half-circle{
2width: 60px; 
3height: 120px; 
4border-radius: 60px 0 0 60px;
5background: #15DEA5;
6}<body>
7
8<div class ="half-circle"></div>
9</body> .half-circle {
10        width: 60px;
11        height: 120px;
12        border-top-left-radius: 110px;
13        border-bottom-left-radius: 110px;
14        border: 10px solid gray;
15        border-right: 0;
16    }
17   <body>
18        <div class ="half-circle"></div>
19   </body>
20

1import pygame
2pygame.init()
3
4win = pygame.display.set_mode((800,600))
5pygame.display.set_caption("Game")
6
7playerX = 380 #Player X coordinate
8playerY = 380 #Player Y coordinate
9playerXVel = 10 #Horizontal Velocity
10playerYVel = 10 #Vertical Velocity
11overworld = (248, 192, 117)
12
13run = True
14
15while run: #The game starts running
16    win.fill(overworld)
17    pygame.time.delay(30)
18
19    for event in pygame.event.get(): #You can stop the game now too
20        if event.type == pygame.QUIT:
21            run = False
22
23    class Player: #This is you
24        def __init__(self):
25            self.rect = pygame.Rect(playerX,playerY,50,50)
26    player = Player()
27
28    class Wall: #The walls
29        def __init__(self, pos):
30            walls.append(self)
31            self.rect = pygame.Rect(pos[0], pos[1], 50, 50)
32    walls = []
33    
34    keys = pygame.key.get_pressed()  #To retain the feel of retro video games, I have made it impossible to walk diagonally
35    if keys[pygame.K_w] and not keys[pygame.K_a] and not keys[pygame.K_d]:
36        playerY -= playerYVel
37    if keys[pygame.K_a] and not keys[pygame.K_w] and not keys[pygame.K_s]:
38        playerX -= playerXVel
39    if keys[pygame.K_s] and not keys[pygame.K_a] and not keys[pygame.K_d]:
40        playerY += playerYVel
41    if keys[pygame.K_d] and not keys[pygame.K_s] and not keys[pygame.K_w]:
42        playerX += playerXVel
43
44    #I copied this section of code
45    #Credit: https://www.pygame.org/project-Rect+Collision+Response-1061-.html
46    level = [
47        "WWWWWWWWWWWWWWWW",
48        "W              W",
49        "W              W",
50        "W              W",
51        "W              W",
52        "W              W",
53        "W              W",
54        "W              W",
55        "W              W",
56        "W              W",
57        "W              W",
58        "WWWWWWWWWWWWWWWW",
59    ]
60    x = y = 0
61    for row in level:
62        for col in row:
63            if col == "W":
64                Wall((x, y)) 
65            x += 50
66        y += 50
67        x = 0
68
69    #Drawing every rectangle in :3
70    pygame.draw.rect(win, (0, 255, 0), player.rect)
71    for wall in walls:
72        pygame.draw.rect(win, (143, 41, 3), wall.rect)
73
74    pygame.display.update()
75pygame.quit()
76        for allwalls in walls:
77            if not player.rect.colliderect(allwalls):
78                playerY -= playerYVel
79oldPlyerX, oldPlyerY = player.rect.topleft          # store player position
80
81keys = pygame.key.get_pressed()
82if keys[pygame.K_w] and not keys[pygame.K_a] and not keys[pygame.K_d]:
83    player.rect.y -= playerYVel
84if keys[pygame.K_a] and not keys[pygame.K_w] and not keys[pygame.K_s]:
85    player.rect.x -= playerXVel
86if keys[pygame.K_s] and not keys[pygame.K_a] and not keys[pygame.K_d]:
87    player.rect.y += playerYVel
88if keys[pygame.K_d] and not keys[pygame.K_s] and not keys[pygame.K_w]:
89    player.rect.x += playerXVel
90
91for allwalls in walls:
92    if player.rect.colliderect(allwalls):
93        player.rect.topleft = oldPlyerX, oldPlyerY # restore player position
94

1import pygame
2pygame.init()
3
4win = pygame.display.set_mode((800,600))
5pygame.display.set_caption("Game")
6
7playerX = 380 #Player X coordinate
8playerY = 380 #Player Y coordinate
9playerXVel = 10 #Horizontal Velocity
10playerYVel = 10 #Vertical Velocity
11overworld = (248, 192, 117)
12
13run = True
14
15while run: #The game starts running
16    win.fill(overworld)
17    pygame.time.delay(30)
18
19    for event in pygame.event.get(): #You can stop the game now too
20        if event.type == pygame.QUIT:
21            run = False
22
23    class Player: #This is you
24        def __init__(self):
25            self.rect = pygame.Rect(playerX,playerY,50,50)
26    player = Player()
27
28    class Wall: #The walls
29        def __init__(self, pos):
30            walls.append(self)
31            self.rect = pygame.Rect(pos[0], pos[1], 50, 50)
32    walls = []
33    
34    keys = pygame.key.get_pressed()  #To retain the feel of retro video games, I have made it impossible to walk diagonally
35    if keys[pygame.K_w] and not keys[pygame.K_a] and not keys[pygame.K_d]:
36        playerY -= playerYVel
37    if keys[pygame.K_a] and not keys[pygame.K_w] and not keys[pygame.K_s]:
38        playerX -= playerXVel
39    if keys[pygame.K_s] and not keys[pygame.K_a] and not keys[pygame.K_d]:
40        playerY += playerYVel
41    if keys[pygame.K_d] and not keys[pygame.K_s] and not keys[pygame.K_w]:
42        playerX += playerXVel
43
44    #I copied this section of code
45    #Credit: https://www.pygame.org/project-Rect+Collision+Response-1061-.html
46    level = [
47        "WWWWWWWWWWWWWWWW",
48        "W              W",
49        "W              W",
50        "W              W",
51        "W              W",
52        "W              W",
53        "W              W",
54        "W              W",
55        "W              W",
56        "W              W",
57        "W              W",
58        "WWWWWWWWWWWWWWWW",
59    ]
60    x = y = 0
61    for row in level:
62        for col in row:
63            if col == "W":
64                Wall((x, y)) 
65            x += 50
66        y += 50
67        x = 0
68
69    #Drawing every rectangle in :3
70    pygame.draw.rect(win, (0, 255, 0), player.rect)
71    for wall in walls:
72        pygame.draw.rect(win, (143, 41, 3), wall.rect)
73
74    pygame.display.update()
75pygame.quit()
76        for allwalls in walls:
77            if not player.rect.colliderect(allwalls):
78                playerY -= playerYVel
79oldPlyerX, oldPlyerY = player.rect.topleft          # store player position
80
81keys = pygame.key.get_pressed()
82if keys[pygame.K_w] and not keys[pygame.K_a] and not keys[pygame.K_d]:
83    player.rect.y -= playerYVel
84if keys[pygame.K_a] and not keys[pygame.K_w] and not keys[pygame.K_s]:
85    player.rect.x -= playerXVel
86if keys[pygame.K_s] and not keys[pygame.K_a] and not keys[pygame.K_d]:
87    player.rect.y += playerYVel
88if keys[pygame.K_d] and not keys[pygame.K_s] and not keys[pygame.K_w]:
89    player.rect.x += playerXVel
90
91for allwalls in walls:
92    if player.rect.colliderect(allwalls):
93        player.rect.topleft = oldPlyerX, oldPlyerY # restore player position
94import pygame
95pygame.init()
96
97win = pygame.display.set_mode((800,600))
98pygame.display.set_caption("Game")
99
100playerXVel = 10 #Horizontal Velocity
101playerYVel = 10 #Vertical Velocity
102overworld = (248, 192, 117)
103
104class Player: #This is you
105    def __init__(self):
106        self.rect = pygame.Rect(380,380,50,50)
107player = Player()
108
109class Wall: #The walls
110    def __init__(self, pos):
111        walls.append(self)
112        self.rect = pygame.Rect(pos[0], pos[1], 50, 50)
113walls = []
114
115#I copied this section of code
116#Credit: https://www.pygame.org/project-Rect+Collision+Response-1061-.html
117level = [
118    "WWWWWWWWWWWWWWWW",
119    "W              W",
120    "W              W",
121    "W              W",
122    "W              W",
123    "W              W",
124    "W              W",
125    "W              W",
126    "W              W",
127    "W              W",
128    "W              W",
129    "WWWWWWWWWWWWWWWW",
130]
131x = y = 0
132for row in level:
133    for col in row:
134        if col == "W":
135            Wall((x, y)) 
136        x += 50
137    y += 50
138    x = 0
139
140run = True
141
142while run: #The game starts running
143    win.fill(overworld)
144    pygame.time.delay(30)
145
146    for event in pygame.event.get(): #You can stop the game now too
147        if event.type == pygame.QUIT:
148            run = False
149
150    oldPlyerX, oldPlyerY = player.rect.topleft
151    keys = pygame.key.get_pressed()  #To retain the feel of retro video games, I have made it impossible to walk diagonally
152    if keys[pygame.K_w] and not keys[pygame.K_a] and not keys[pygame.K_d]:
153        player.rect.y -= playerYVel
154    if keys[pygame.K_a] and not keys[pygame.K_w] and not keys[pygame.K_s]:
155        player.rect.x -= playerXVel
156    if keys[pygame.K_s] and not keys[pygame.K_a] and not keys[pygame.K_d]:
157        player.rect.y += playerYVel
158    if keys[pygame.K_d] and not keys[pygame.K_s] and not keys[pygame.K_w]:
159        player.rect.x += playerXVel
160
161    for allwalls in walls:
162        if player.rect.colliderect(allwalls):
163            player.rect.topleft = oldPlyerX, oldPlyerY
164
165    #Drawing every rectangle in :3
166    pygame.draw.rect(win, (0, 255, 0), player.rect)
167    for wall in walls:
168        pygame.draw.rect(win, (143, 41, 3), wall.rect)
169
170    pygame.display.update()
171pygame.quit()
172

1using System;
2                    
3public class Program
4{
5    // Player 1 cordinates
6    public static float p1x = 2;
7    public static float p1y = 3;
8    public static float p1rotation = 0; // In degrees 0-360
9    
10    // Player 2 cordinates
11    public static float p2x = 6;
12    public static float p2y = 4;
13    
14    // Player 1 needed degree to face Player 2
15    public static float needed_distance;
16    
17    public static void Main()
18    {
19        needed_distance = ??; // no clue how to get this value ...
20        Console.WriteLine("The needed distance is: "+needed_distance);
21        
22    }
23}private static float Rotation(float p1x, float p1y, float p2x, float p2y) =>
24  (float)(Math.Atan2(p1x - p2x, p2y - p1y) * 180.0 / Math.PI + 630) % 360.0f;
25
26private static float Distance(float p1x, float p1y, float p2x, float p2y) =>
27  (float)Math.Sqrt((p1x - p2x) * (p1x - p2x) + (p1y - p2y) * (p1y - p2y));
28

1using System;
2                    
3public class Program
4{
5    // Player 1 cordinates
6    public static float p1x = 2;
7    public static float p1y = 3;
8    public static float p1rotation = 0; // In degrees 0-360
9    
10    // Player 2 cordinates
11    public static float p2x = 6;
12    public static float p2y = 4;
13    
14    // Player 1 needed degree to face Player 2
15    public static float needed_distance;
16    
17    public static void Main()
18    {
19        needed_distance = ??; // no clue how to get this value ...
20        Console.WriteLine("The needed distance is: "+needed_distance);
21        
22    }
23}private static float Rotation(float p1x, float p1y, float p2x, float p2y) =>
24  (float)(Math.Atan2(p1x - p2x, p2y - p1y) * 180.0 / Math.PI + 630) % 360.0f;
25
26private static float Distance(float p1x, float p1y, float p2x, float p2y) =>
27  (float)Math.Sqrt((p1x - p2x) * (p1x - p2x) + (p1y - p2y) * (p1y - p2y));
28Console.WriteLine(Rotation(2, 3, 6, 4));
29

1using System;
2                    
3public class Program
4{
5    // Player 1 cordinates
6    public static float p1x = 2;
7    public static float p1y = 3;
8    public static float p1rotation = 0; // In degrees 0-360
9    
10    // Player 2 cordinates
11    public static float p2x = 6;
12    public static float p2y = 4;
13    
14    // Player 1 needed degree to face Player 2
15    public static float needed_distance;
16    
17    public static void Main()
18    {
19        needed_distance = ??; // no clue how to get this value ...
20        Console.WriteLine("The needed distance is: "+needed_distance);
21        
22    }
23}private static float Rotation(float p1x, float p1y, float p2x, float p2y) =>
24  (float)(Math.Atan2(p1x - p2x, p2y - p1y) * 180.0 / Math.PI + 630) % 360.0f;
25
26private static float Distance(float p1x, float p1y, float p2x, float p2y) =>
27  (float)Math.Sqrt((p1x - p2x) * (p1x - p2x) + (p1y - p2y) * (p1y - p2y));
28Console.WriteLine(Rotation(2, 3, 6, 4));
29194.0362548828125
30

1using System;
2                    
3public class Program
4{
5    // Player 1 cordinates
6    public static float p1x = 2;
7    public static float p1y = 3;
8    public static float p1rotation = 0; // In degrees 0-360
9    
10    // Player 2 cordinates
11    public static float p2x = 6;
12    public static float p2y = 4;
13    
14    // Player 1 needed degree to face Player 2
15    public static float needed_distance;
16    
17    public static void Main()
18    {
19        needed_distance = ??; // no clue how to get this value ...
20        Console.WriteLine("The needed distance is: "+needed_distance);
21        
22    }
23}private static float Rotation(float p1x, float p1y, float p2x, float p2y) =>
24  (float)(Math.Atan2(p1x - p2x, p2y - p1y) * 180.0 / Math.PI + 630) % 360.0f;
25
26private static float Distance(float p1x, float p1y, float p2x, float p2y) =>
27  (float)Math.Sqrt((p1x - p2x) * (p1x - p2x) + (p1y - p2y) * (p1y - p2y));
28Console.WriteLine(Rotation(2, 3, 6, 4));
29194.0362548828125
30float rotation1 = ...;
31
32float requiredRotation = (Rotation(p1x, p1y, p2x, p2y) - 
33   (rotation1 % 360f) + 360f) % 360f;    
34

1[
2{"923390702359048212": 5},
3{"462291477964259329": 1},
4{"803390252265242634": 3},
5{"824114065445486592": 2},
6{"832041337968263178": 4}
7]
8amount = 0
9for member in server:
10    if member.id != server.member.id:
11        amount = amount + 1
12    else:
13        print(amount)
14        print(str(member.id), str(server.member.id))
15        print(jsondata[amount][str(server.member.id)])
16        break
17    
18jsondata[amount][str(server.member.id) = jsondata[amount][str(server.member.id)] + 1
19    def goalscored():
20        amount = 0
21        for member in server:
22            if member.id != server.member.id:
23                amount = amount + 1
24            else:
25                print(amount)
26                break
27        with open('Goals.json','w') as f:
28            jsondata = json.load(f)
29            jsondata[amount][str(server.member.id) = jsondata[amount][str(server.member.id)] + 1
30            json.dump(jsondata,f)
31    
32    def firstgoal(server.member.id):
33        with open('Goals.json','w') as f:
34            jsondata = json.load(f)
35            amount = 0
36            goalscored = 1
37            totalmembers = server.members.amount
38            for member in server:
39                if membed.id !=server.member.id:
40                    amount = amount + 1
41                if amount == totalmembers:
42                    NewScore = {user.id:goalscored}
43                    json.dump(NewScore,f)
44# file.json
45{
46 "923390702359048212": 5,
47 "462291477964259329": 1,
48 "803390252265242634": 3,
49 "824114065445486592": 2,
50 "832041337968263178": 4
51}
52
53def goalscored():
54    with open("Goals.json", "r") as f:
55        jsondata = json.load(f)
56        # Make sure your id is not int but str
57        if server.member.id not in jsondata:  # first goal case
58            jsondata[server.member.id] = 0
59        jsondata[server.member.id] += 1
60
61    with open("Goals.json", "w") as f:
62        json.dump(jsondata, f)
63