content update

Author: codercommand

.gitattributes

@@ -0,0 +1,85 @@
+# Common settings that generally should always be used with your language specific settings
+
+# Auto detect text files and perform LF normalization
+*          text=auto
+
+#
+# The above will handle all files NOT mentioned below
+#
+
+# Documents
+*.bibtex   text diff=bibtex
+*.doc      diff=astextplain
+*.DOC      diff=astextplain
+*.docx     diff=astextplain
+*.DOCX     diff=astextplain
+*.dot      diff=astextplain
+*.DOT      diff=astextplain
+*.pdf      diff=astextplain
+*.PDF      diff=astextplain
+*.rtf      diff=astextplain
+*.RTF      diff=astextplain
+*.md       text diff=markdown
+*.mdx      text diff=markdown
+*.tex      text diff=tex
+*.adoc     text
+*.textile  text
+*.mustache text
+*.csv      text eol=crlf
+*.tab      text
+*.tsv      text
+*.txt      text
+*.sql      text
+*.epub     diff=astextplain
+
+# Graphics
+*.png      binary
+*.jpg      binary
+*.jpeg     binary
+*.gif      binary
+*.tif      binary
+*.tiff     binary
+*.ico      binary
+# SVG treated as text by default.
+*.svg      text
+# If you want to treat it as binary,
+# use the following line instead.
+# *.svg    binary
+*.eps      binary
+
+# Scripts
+*.bash     text eol=lf
+*.fish     text eol=lf
+*.sh       text eol=lf
+*.zsh      text eol=lf
+# These are explicitly windows files and should use crlf
+*.bat      text eol=crlf
+*.cmd      text eol=crlf
+*.ps1      text eol=crlf
+
+# Serialisation
+*.json     text
+*.toml     text
+*.xml      text
+*.yaml     text
+*.yml      text
+
+# Archives
+*.7z       binary
+*.gz       binary
+*.tar      binary
+*.tgz      binary
+*.zip      binary
+
+# Text files where line endings should be preserved
+*.patch    -text
+
+#
+# /////////Exclude files from exporting////////
+# You can tell Git not to export certain files or directories when generating an archive.
+# If there is a subdirectory or file that you don’t want to include in your archive file but that,
+# you do want checked into your project, you can determine those files via the export-ignore attribute.
+
+# .gitattributes export-ignore
+# .gitignore     export-ignore
+# .gitkeep       export-ignore

content/arcade blog/arcade GDD.md

@@ -1,5 +1,5 @@
 +++
 title = 'Arcade GDD'
 date = 2024-04-25T17:04:30+01:00
-draft = false
+draft = true
 +++

content/projects/Demise/bt-blueprint-of-ammo-truck.png

@@ -0,0 +1,40 @@
++++
+title = 'Demise'
+date = 2022-12-01
+draft = false
++++
+
+![Image](spaceship.png)
+> ^ All the cars in this photo are using AI to navigate the city and do their own tasks. 
+
+
+
+# About the Project
+
+![Image](shot-missile.png)
+> ^ The player is shooting another player with a homing missile. The missile is the little yellow dot on the screen between the two spaceships.
+
+I made this game solo around Christmas of *2022* during my 2nd year of university. It’s 3D spaceship PvP demo that works on LAN.
+
+All the net-code and AI is made in Blueprints.
+
+
+
+# The Inner Workings of Demise
+
+I made the spaceship shoot missiles that chase the nearest target. The target can be spaceships, other missiles, or green trucks.
+
+I wanted missiles to only see what’s in front of them, to do this I used the *AIPerception* component and custom Blueprint (BP) code to get the nearest target in vision.
+
+![Image](missile-code-snippet.png)
+> ^ This is the code that controls the AI perception (targeting system) on the missile. 
+
+For the city I populated it with cars that have different AI.
+
+All cars have a wondering mechanic to drive to random locations. The police car and green van variants expand this logic.
+
+- Police cars will randomly chase and stop other cars or vans.
+- Green vans will stop at certain towers to put ammo back on the map so a spaceship can get more ammunition.
+
+![Image](bt-blueprint-of-ammo-truck.png)
+> ^ Behavior tree of the green van (ammo truck) that controls its AI.

content/projects/Demise/index.md

@@ -0,0 +1,94 @@
++++
+title = 'LANSpace'
+date = 2021-08-28
+draft = false
++++
+
+![Image](a.png)
+> ^ Picture showing 2 games running in the same PC on LAN.
+
+[Repository](https://github.com/codercommand/LANSpace)
+
+In *2021 Falmouth University* advised all programming students to make a 2D game using Python and Pygame before starting their course in September.
+
+I decided to make mine a multiplayer spaceship game, and use a unique way of communicating I had theorised. The purpose of this was to experiment with a different communication method to make a game that doesn’t need a server or a host to work.
+
+The end result was anyone can join or leave the local area network (LAN) at any time without negatively interrupting the experience of other players. The player limit for the LAN is 255 players technically, but in practice it only works with about 20 players on LAN before the LAN begins to suffer networking issues.
+
+While this style of network design has drawbacks, I’m pleased that the experiment was successful.
+
+
+
+# The Inner Workings of LANSpace
+
+To network the game I use the UDP Broadcast protocol. Every client listens to port 8080 for other clients already on the network. After learning who is on the network, the client will assign itself a unique number and begin broadcasting its world position and other data on port 8080.
+
+All the clients listen for broadcasts and render the players who are broadcasting.
+
+A death in the game is simulated by not broadcasting the player position. If a client doesn’t receive an update to the location of a player within 0.03 seconds, then the player is removed from their game. Respawning is as simple as broadcasting the player position again.
+
+```python
+# A generator used for reading the game network before each game loop.
+def network_reader(main_player_id: int) -> list:
+...
+...
+...
+		# Removes enemies that have stopped playing for more than 1 second.
+		for x in range(len(game_state)-1, -1, -1):
+
+				# Remoevs enemy players that have quit playing.
+				if game_state[x].type == Type.Actor:
+						if (time.time() - game_state[x].last_update) > 0.03:
+								game_state.pop(x)
+								continue
+```
+> ^ Code that controls which players are rendered to the screen.
+
+I also made functions to serialized and deserialized player data (like position) from and to bytes. I did this to reduce packet size and because it was fun. There was also a performance concern. I believed it to be faster to have custom serialization code built to purpose instead of processing text or JSON.
+
+```python
+# Base type used to make the two seperate player types: Avatar & Player.
+class Actor:
+    def __init__(self, id: int, _type: Type, rotation: int, x: int, y: int, shiptype: int) -> None:
+        self.type =     _type
+        self.id =       id
+        self.rotation = rotation # I only want to store 0-360 in rotation, nothing other.
+        self.x =        x
+        self.y =        y
+        self.shiptype = shiptype # Ship type must be between and including 1-4
+
+        self.spaceship_cache = None
+        self.size = 42
+
+    def to_bytes(self) -> bytes:
+        data = []
+
+        data.append(self.type)
+        data.append(self.id)
+        for x in self.rotation.to_bytes(length=2, byteorder="big", signed=False):
+            data.append(x)
+        for x in int(self.x).to_bytes(length=4, byteorder="big", signed=False):
+            data.append(x)
+        for x in int(self.y).to_bytes(length=4, byteorder="big", signed=False):
+            data.append(x)
+        data.append(self.shiptype)
+
+        return bytes(data)
+
+    def from_bytes(self, data: bytes) -> None:
+        self.type =     data[0]
+        self.id =       data[1]
+        self.rotation = int.from_bytes(data[2:4], byteorder="big", signed=False)
+        self.x =        int.from_bytes(data[4:8], byteorder="big", signed=False)
+        self.y =        int.from_bytes(data[8:12], byteorder="big", signed=False)
+        self.shiptype = data[12]
+```
+> ^ Code showing the custom serialisation and deserialisation functions I made for the player.
+
+
+
+# Flaws with LANSpace
+
+It’s really easy to cheat because there is no authority for the network state, everyone is responsible for their individual character state. For example, to make your player immortal you would continue to broadcast you ships position, this would make you immune to damage because on everyone else's screens you would never die. The game is intended to be played on LAN though so it’s not a big concern. You would be playing with friends or people you know so if you’re cheating it’s because you and your friends want to.
+
+The other problem is that because the game is broadcasting to everyone on the network it has the potential to use up all the bandwidth available for every device. This causes the internet to become slow, similar to a denial of service attack. On testing: 20 players is fine, you can get away with 50, anything higher and the network can’t handle it. The internet will stop working properly with anything over ~80 for everyone connected, including people not playing the game.

content/projects/Demise/missile-code-snippet.png

@@ -0,0 +1,92 @@
++++
+title = 'Sentinel'
+date = 2022-01-31
+draft = false
++++
+
+![Image](striking-enemy.png)
+
+
+
+# About the Project
+
+While doing my 1st year of university in 2022, I participated in a game jam on [itch.io](http://itch.io). It was a 72 hour jam with a theme of ***protect***.
+
+I made the game solo in Godot and used GDScript. This is the 3rd project I’ve ever made in Godot. All the assets for the project are from [itch.io](http://itch.io).
+
+The game loop is simple, kill skeletons till you die then repeat and try to beat your last high score. Current record is by someone else who played the game. Their record is 1483.
+
+![Image](play-menu.png)
+> ^ Picture of the main menu.
+
+![Image](banner.png)
+> ^ Picture of player killing a skeleton. There is also a dead skeleton on the ground.
+
+![Image](died.png)
+> ^ Picture of dead player.
+
+
+
+# Code Snippets
+
+This is some ***GDScript*** code snippets from the player script.
+
+```cpp
+func _process(delta):
+	if not died:
+		input_controller()
+		attack_enemy_controller()
+		animation_controller()
+		physics_controller(delta)
+		
+		velocity = move_and_slide(velocity, Vector2.UP)
+		
+		levelup()
+```
+> ^ The *update* function. Logic for the player uses a state machine separated between multiple functions. These functions are all called from the player *update* function.
+
+```cpp
+func animation_controller():
+	"""
+	animation_controller is an animation statemachine.
+	It controls which animations should be playing based on player input.
+	"""
+	
+	if not animation_locked and not died:
+		if dead:
+			$AnimatedSprite.animation = "death"
+			animation_locked = true
+			died = true
+			$RunAudio.stop()
+			
+			$DeathTimer.start()
+			
+		elif not is_on_floor() and $AnimatedSprite.animation == "jump":
+			$AnimatedSprite.animation = "jumpTransition"
+			animation_locked = true
+			
+		elif not is_on_floor():
+			$AnimatedSprite.animation = "fall"
+			$RunAudio.stop()
+			
+		elif jumping and is_on_floor():
+			$AnimatedSprite.animation = "jump"
+			animation_locked = true
+			$RunAudio.stop()
+			
+		elif attacking:
+			$AnimatedSprite.animation = get_attack_animation()
+			animation_locked = true
+			$AttackAudio.play()
+			$RunAudio.stop()
+			
+		elif running:
+			$AnimatedSprite.animation = "run"
+			if not $RunAudio.playing:
+				$RunAudio.play()
+			
+		else:
+			$AnimatedSprite.animation = "idle"
+			$RunAudio.stop()
+```
+> ^ This is the function responsible for handling the player animations. The logic is all state based, and is called in the code snippet above that shows the player *update* function.

content/projects/Demise/shot-missile.png

@@ -1,5 +1,5 @@
 +++
 title = 'Swamp Fell'
-date = 2024-04-25T17:06:38+01:00
+date = 2024-05-01
 draft = false
 +++