send scratch link pls

i donāt see any thing that makes sense on that profile also whats wrong with my itch game

just very simple, short, no animation, and you canāt see where you are when you freeze your player

its a game jam game game jam games are supposed to be short

thatās really short though

i wanted to make it longer

Compiled a list of scratch projects Iām most proud of (some are just other peopleās projects with more stuff):

https://scratch.mit.edu/projects/684411992

https://scratch.mit.edu/projects/628945188

https://scratch.mit.edu/projects/585744280

https://scratch.mit.edu/projects/611593804

https://scratch.mit.edu/projects/536618834

https://scratch.mit.edu/projects/672744638

https://scratch.mit.edu/projects/476759024

https://scratch.mit.edu/projects/499154358

https://scratch.mit.edu/projects/494522425

but letās stop cuz weāre getting off-topic

also someone move this to off-topic section please, itāll get more attention that way

pretty good i had some fun scratch projects but they got deleted when the evil scratch team banded me i had this shooter game (it was non violent and had nothing to do with me getting band) and i had a random art maker but the rest where not that great

Nice game @TheCodingCrusader22

While it is not CodeCombat it is fun do you have any game dev projects to share?

no codecombat game dev is kinda garbadge

Do you have them now?

Here are some of my games (although they are more like math concepts made into games):

P.S. Sorry abut the lag, codecombat does not like my algorithms.

no, I have school now prob never gonna find them again lol :|

coin thing cool idea

why does coco not like your algorithms send code pls

I think I do, but I am not sure if there are goals and stuff there. I will try to find something tomorrow.

For my first game, I have to constantly triangulate the positions for the ogres, which takes a toll on the server.

## Code summary

This is the code for the ogres chasing the hero. My code completes a lot of calculations to position each ogre. Additionally, I designated a lead ogre that runs the calculations, to minimize the number of times the calculations are run. I could probably cut down on the lag with better code, but I have not gotten around to doing it yet.

```
def encircle(event):
while True:
unit = event.target
leader = findLeader(unit)
enemy = leader.findNearestEnemy()
friends = leader.findFriends()
number = len(friends)
for friendIndex in range (len(friends)):
if friends[friendIndex] == unit:
number = friendIndex
if enemy:
if unit == leader:
direction = 0
for i in range (len(friends)+1):
length = len(friends)+1
friend = friends[i]
if friend == null:
friend = unit
rate = 0.2*friend.maxSpeed
position = {"x": enemy.pos.x+Math.cos(direction)*(friend.distanceTo(enemy)-rate), "y": enemy.pos.y+Math.sin(direction)*(friend.distanceTo(enemy)-rate)}
direction += (Math.PI*2)/length
if direction >= Math.PI*2:
direction -= Math.PI*2
order = unitOrderNumber(friend)
if order != null:
orders[order] = [friend.name, position.x, position.y]
else:
orders.append([friend.name, position.x, position.y])
if unit.distanceTo(enemy) <= unit.attackRange:
unit.attack(enemy)
else:
order = orders[unitOrderNumber(unit)]
if order and order[2]:
unit.move({"x": order[1], "y": order[2]})
```

For my second game, I have to make a bunch of calculations to get the target positions for the AI.

## Code summary

I group the positions of the ogres, then use these functions to find the position to attack for each group using the posOfGroup(group) function.

```
def posOfGroup(group):
positions = []
for place in group:
positions.append(place)
pos = averageOfCircles(positions, range)
return pos
def averageOfCircles(points, radius):
averages = []
positions = []
if len(points) == 1:
return {"x":points[0].x, "y": points[0].y}
for i in range(len(points)):
point = points[i]
for j in range(len(points)):
p = points[j]
if point != p and j>i and intersectionPointsOfCircles(point, p, radius) != []:
for position in intersectionPointsOfCircles(point, p, radius):
positions.append(position)
selectPositions = []
for position in positions:
select = True
for point in points:
if distanceBetween(position, point) > radius+0.000000000001:
select = False
if select:
selectPositions.append(position)
positions = selectPositions
if len(positions) == 0:
return null
x = 0
y = 0
for average in positions:
x += average.x
y += average.y
x /= len(positions)
y /= len(positions)
return {"x": x, "y": y}
def intersectionPointsOfCircles(a, b, radius):
direction = directionOf(b.x-a.x, b.y-a.y)
distance = distanceBetween(a, b)
newB = {"x": a.x+distance, "y": a.y}
positions = []
if distance > radius*2:
# If the distance is too great for the circles to have intersection points, return nothing
return positions
if distance == radius*2:
# If the distance is equal to the diameter of a circle, the intersection point is where the edges of the circles touch
pos = {"x": null, "y": null}
pos.x = a.x+Math.cos(direction)*radius
pos.y = a.y+Math.sin(direction)*radius
positions.append(pos)
else:
# If the distance is less than the diameter of a circle, there are two intersection points
pos1 = {"x": null, "y": null}
pos2 = {"x": null, "y": null}
# Find where the intersection points would lie on the x-axis if circle b were at a 0 degree angle to circle a
pos1.x = (distance/2)
pos2.x = (distance/2)
# Find where the intersection points would lie on the y-axis if circle b were at a 0 degree angle to circle a by using the pathagorean theorem (hypotenuse^2-x^2 = y^2)
pos1.y = Math.sqrt((radius*radius)-((distance/2)*(distance/2)))
pos2.y = -1*Math.sqrt((radius*radius)-((distance/2)*(distance/2)))
# Now, rotate the points around circle a, in the direction circle b is to circle a.
d = directionOf(pos1.x, pos1.y)
pos1.x = a.x+Math.cos(d+direction)*radius
pos1.y = a.y+Math.sin(d+direction)*radius
d = directionOf(pos2.x, pos2.y)
pos2.x = a.x+Math.cos(d+direction)*radius
pos2.y = a.y+Math.sin(d+direction)*radius
positions.append(pos1)
positions.append(pos2)
return positions
```