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
1 Like
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
1 Like
also someone move this to off-topic section please, itāll get more attention that way
1 Like
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
2 Likes
Nice game @TheCodingCrusader22
While it is not CodeCombat it is fun do you have any game dev projects to share?
1 Like
no codecombat game dev is kinda garbadge
1 Like
Do you have them now?
1 Like
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.
3 Likes
no, I have school now prob never gonna find them again lol :|
2 Likes
coin thing cool idea
3 Likes
why does coco not like your algorithms send code pls
1 Like
I think I do, but I am not sure if there are goals and stuff there. I will try to find something tomorrow.
3 Likes
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
2 Likes