Code Sketch
shreyash tarate
Category: Art
clear()
originBottomLeft()
// ============================================================
// ? ROBOT EXPLORER ? FUTURISTIC ROBOTICS
// ============================================================
var t = 0.0
var robotX = 120.0
var robotY = 150.0
var velocityX = 1.2
var velocityY = 0.0
var scannerAngle = 0.0
var obstacleX = 470.0
var obstacleY = 155.0
var alert = false
var alertTimer = 0.0
var messageIndex = 0
var messageTimer = 0.0
val messages = Array(
"EXPLORING...",
"SCANNING ENVIRONMENT",
"ANALYZING OBJECT...",
"OBSTACLE DETECTED!",
"PATH CALCULATED",
"MISSION CONTINUES"
)
// ============================================================
// BACKGROUND
// ============================================================
def background(canvas: CanvasDraw): Unit = {
canvas.background(
3,
8,
22
)
// Stars / data particles
for (i <- 0 until 45) {
val x =
(i * 97 + t * (8 + i % 4)) % cwidth
val y =
(i * 53) % cheight
canvas.fill(
40,
200,
255,
100
)
canvas.noStroke()
canvas.ellipse(
x,
y,
2,
2
)
}
// Ground
canvas.stroke(
20,
70,
100,
180
)
canvas.strokeWeight(1)
var x = 0.0
while (x < cwidth) {
canvas.line(
x,
80,
x + 120,
0
)
x += 60
}
var y = 80.0
while (y < cheight) {
canvas.line(
0,
y,
cwidth,
y
)
y += 35
}
canvas.stroke(
30,
150,
200
)
canvas.line(
0,
80,
cwidth,
80
)
}
// ============================================================
// OBSTACLE
// ============================================================
def drawObstacle(canvas: CanvasDraw): Unit = {
val pulse =
math.sin(t * 5.0) * 5.0
// Glow
canvas.fill(
255,
50,
70,
25
)
canvas.noStroke()
canvas.ellipse(
obstacleX,
obstacleY + 25,
90 + pulse,
90 + pulse
)
// Object
canvas.fill(
50,
30,
45
)
canvas.stroke(
255,
70,
90
)
canvas.strokeWeight(3)
canvas.rect(
obstacleX - 35,
obstacleY - 10,
70,
70
)
// Warning symbol
canvas.fill(
255,
220,
60
)
canvas.noStroke()
canvas.ellipse(
obstacleX,
obstacleY + 25,
15,
15
)
}
// ============================================================
// ROBOT
// ============================================================
def drawRobot(canvas: CanvasDraw): Unit = {
val bounce =
math.sin(t * 6.0) * 2.0
val rx = robotX
val ry = robotY + bounce
// ========================================================
// ROBOT GLOW
// ========================================================
canvas.fill(
30,
200,
255,
25
)
canvas.noStroke()
canvas.ellipse(
rx,
ry + 55,
150,
130
)
// ========================================================
// BODY
// ========================================================
canvas.fill(
45,
60,
80
)
canvas.stroke(
70,
230,
255
)
canvas.strokeWeight(3)
canvas.rect(
rx - 45,
ry + 25,
90,
65
)
// ========================================================
// CHEST DISPLAY
// ========================================================
canvas.fill(
4,
20,
38
)
canvas.noStroke()
canvas.rect(
rx - 30,
ry + 42,
60,
28
)
// Moving energy bars
for (i <- 0 until 4) {
val bar =
8.0 +
math.abs(
math.sin(t * 4.0 + i)
) * 12.0
canvas.fill(
50,
230,
255
)
canvas.rect(
rx - 23 + i * 12,
ry + 48,
7,
bar
)
}
// ========================================================
// HEAD
// ========================================================
canvas.fill(
65,
80,
100
)
canvas.stroke(
80,
240,
255
)
canvas.strokeWeight(3)
canvas.rect(
rx - 50,
ry + 90,
100,
65
)
// Face
canvas.fill(
3,
18,
35
)
canvas.noStroke()
canvas.rect(
rx - 40,
ry + 103,
80,
40
)
// ========================================================
// EYES
// ========================================================
val eyeGlow =
8.0 +
math.sin(t * 8.0) * 2.0
canvas.fill(
60,
240,
255
)
canvas.ellipse(
rx - 20,
ry + 123,
eyeGlow * 2,
eyeGlow
)
canvas.ellipse(
rx + 20,
ry + 123,
eyeGlow * 2,
eyeGlow
)
// ========================================================
// ANTENNA
// ========================================================
canvas.stroke(
80,
230,
255
)
canvas.strokeWeight(3)
canvas.line(
rx,
ry + 155,
rx,
ry + 180
)
if (alert) {
canvas.fill(
255,
50,
70
)
} else {
canvas.fill(
60,
255,
130
)
}
canvas.noStroke()
canvas.ellipse(
rx,
ry + 185,
12,
12
)
// ========================================================
// LEFT ARM
// ========================================================
val arm =
math.sin(t * 4.0) * 12.0
canvas.stroke(
70,
220,
255
)
canvas.strokeWeight(7)
canvas.line(
rx - 45,
ry + 65,
rx - 75,
ry + 40 + arm
)
canvas.fill(
70,
220,
255
)
canvas.noStroke()
canvas.ellipse(
rx - 80,
ry + 37 + arm,
18,
18
)
// ========================================================
// RIGHT ROBOT ARM
// ========================================================
canvas.stroke(
70,
220,
255
)
canvas.strokeWeight(7)
canvas.line(
rx + 45,
ry + 65,
rx + 75,
ry + 40 - arm
)
canvas.fill(
70,
220,
255
)
canvas.noStroke()
canvas.ellipse(
rx + 80,
ry + 37 - arm,
18,
18
)
// ========================================================
// WHEELS
// ========================================================
canvas.fill(
20,
25,
35
)
canvas.stroke(
80,
230,
255
)
canvas.strokeWeight(3)
canvas.ellipse(
rx - 32,
ry + 15,
35,
35
)
canvas.ellipse(
rx + 32,
ry + 15,
35,
35
)
canvas.fill(
80,
240,
255
)
canvas.noStroke()
canvas.ellipse(
rx - 32,
ry + 15,
10,
10
)
canvas.ellipse(
rx + 32,
ry + 15,
10,
10
)
}
// ============================================================
// ROTATING RADAR
// ============================================================
def drawRadar(canvas: CanvasDraw): Unit = {
val cx = robotX
val cy = robotY + 175.0
scannerAngle += 0.045
val length = 115.0
val sx =
cx +
math.cos(scannerAngle) * length
val sy =
cy +
math.sin(scannerAngle) * length
// Radar circle
canvas.noFill()
canvas.stroke(
50,
220,
255,
80
)
canvas.strokeWeight(1)
canvas.ellipse(
cx,
cy,
200,
200
)
canvas.ellipse(
cx,
cy,
140,
140
)
// Radar beam
canvas.stroke(
70,
255,
180,
220
)
canvas.strokeWeight(2)
canvas.line(
cx,
cy,
sx,
sy
)
// Radar point
canvas.fill(
70,
255,
180
)
canvas.noStroke()
canvas.ellipse(
sx,
sy,
7,
7
)
}
// ============================================================
// SCAN LASER
// ============================================================
def drawLaser(canvas: CanvasDraw): Unit = {
val distance =
math.abs(
obstacleX - robotX
)
if (distance < 180) {
canvas.stroke(
255,
60,
80,
180
)
canvas.strokeWeight(2)
canvas.line(
robotX,
robotY + 175,
obstacleX,
obstacleY + 25
)
}
}
// ============================================================
// STATUS PANEL
// ============================================================
def drawStatus(canvas: CanvasDraw): Unit = {
val msg =
messages(messageIndex)
canvas.fill(
5,
20,
40
)
canvas.stroke(
60,
220,
255
)
canvas.strokeWeight(2)
canvas.rect(
20,
cheight - 55,
250,
35
)
canvas.fill(
80,
240,
255
)
canvas.noStroke()
canvas.text(
msg,
35,
cheight - 32
)
// Status light
if (alert) {
canvas.fill(
255,
60,
70
)
} else {
canvas.fill(
50,
255,
130
)
}
canvas.ellipse(
250,
cheight - 38,
8,
8
)
}
// ============================================================
// TITLE
// ============================================================
def title(canvas: CanvasDraw): Unit = {
canvas.fill(
220,
245,
255
)
canvas.noStroke()
canvas.text(
"ROBOT EXPLORER",
cwidth / 2.0 - 70,
cheight - 20
)
canvas.fill(
60,
220,
255
)
canvas.text(
"AUTONOMOUS ROBOTICS SYSTEM",
cwidth / 2.0 - 105,
cheight - 40
)
}
// ============================================================
// MAIN SCENE
// ============================================================
def scene(canvas: CanvasDraw): Unit = {
background(canvas)
drawObstacle(canvas)
drawRadar(canvas)
drawLaser(canvas)
drawRobot(canvas)
drawStatus(canvas)
title(canvas)
}
// ============================================================
// ANIMATION
// ============================================================
animateWithCanvasDraw { canvas =>
t += 0.04
// Robot movement
robotX += velocityX
// Obstacle detection
val distance =
math.abs(
obstacleX - robotX
)
if (distance < 150) {
alert = true
alertTimer += 0.04
// Robot changes direction
velocityX = -1.5
} else {
alert = false
}
// Turn around at edges
if (robotX > cwidth - 100) {
velocityX = -1.5
}
if (robotX < 100) {
velocityX = 1.5
}
// Status messages
messageTimer += 0.04
if (messageTimer > 2.0) {
messageTimer = 0.0
messageIndex += 1
if (
messageIndex >= messages.length
) {
messageIndex = 0
}
}
scene(canvas)
}
