Contest for best game development project!

send scratch link pls

moonwatcher348 on Scratch some aren’t shared

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):
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.

1 Like

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

coin thing cool idea

1 Like

why does coco not like your algorithms send code pls

@PeterPalov Do you have any games?

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 =
        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] = [, position.x, position.y]
                        orders.append([, position.x, position.y])
            if unit.distanceTo(enemy) <= unit.attackRange:
                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:
  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):
  selectPositions = []
  for position in positions:
      select = True
      for point in points:
          if distanceBetween(position, point) > radius+0.000000000001:
              select = False
      if select:
  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
      # 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
  return positions