513 lines
10 KiB
Go
513 lines
10 KiB
Go
package main
|
|
|
|
import (
|
|
"math"
|
|
"math/rand"
|
|
|
|
"github.com/gen2brain/raylib-go/raylib"
|
|
|
|
box2d "github.com/neguse/go-box2d-lite/box2dlite"
|
|
)
|
|
|
|
// Game type
|
|
type Game struct {
|
|
World *box2d.World
|
|
TimeStep float64
|
|
}
|
|
|
|
// NewGame - Start new game
|
|
func NewGame() (g Game) {
|
|
g.Init()
|
|
return
|
|
}
|
|
|
|
// Init - Initialize game
|
|
func (g *Game) Init() {
|
|
gravity := box2d.Vec2{0.0, -10.0}
|
|
g.World = box2d.NewWorld(gravity, 10) // 10 iterations
|
|
}
|
|
|
|
// Update - Update game
|
|
func (g *Game) Update() {
|
|
// Keys 1-9 switch demos
|
|
switch raylib.GetKeyPressed() {
|
|
case raylib.KeyOne:
|
|
g.Demo1()
|
|
case raylib.KeyTwo:
|
|
g.Demo2()
|
|
case raylib.KeyThree:
|
|
g.Demo3()
|
|
case raylib.KeyFour:
|
|
g.Demo4()
|
|
case raylib.KeyFive:
|
|
g.Demo5()
|
|
case raylib.KeySix:
|
|
g.Demo6()
|
|
case raylib.KeySeven:
|
|
g.Demo7()
|
|
case raylib.KeyEight:
|
|
g.Demo8()
|
|
case raylib.KeyNine:
|
|
g.Demo9()
|
|
}
|
|
|
|
g.TimeStep = float64(raylib.GetFrameTime())
|
|
|
|
// Physics steps calculations
|
|
g.World.Step(g.TimeStep)
|
|
}
|
|
|
|
// Draw - Draw game
|
|
func (g *Game) Draw() {
|
|
for _, b := range g.World.Bodies {
|
|
g.DrawBody(b)
|
|
}
|
|
for _, j := range g.World.Joints {
|
|
g.DrawJoint(j)
|
|
}
|
|
|
|
raylib.DrawText("Use keys 1-9 to switch current demo", 20, 20, 10, raylib.RayWhite)
|
|
}
|
|
|
|
// DrawBody - Draw body
|
|
func (g *Game) DrawBody(b *box2d.Body) {
|
|
R := box2d.Mat22ByAngle(b.Rotation)
|
|
x := b.Position
|
|
h := box2d.MulSV(0.5, b.Width)
|
|
|
|
o := box2d.Vec2{400, 400}
|
|
S := box2d.Mat22{box2d.Vec2{20.0, 0.0}, box2d.Vec2{0.0, -20.0}}
|
|
|
|
v1 := o.Add(S.MulV(x.Add(R.MulV(box2d.Vec2{-h.X, -h.Y}))))
|
|
v2 := o.Add(S.MulV(x.Add(R.MulV(box2d.Vec2{h.X, -h.Y}))))
|
|
v3 := o.Add(S.MulV(x.Add(R.MulV(box2d.Vec2{h.X, h.Y}))))
|
|
v4 := o.Add(S.MulV(x.Add(R.MulV(box2d.Vec2{-h.X, h.Y}))))
|
|
|
|
raylib.DrawLine(int32(v1.X), int32(v1.Y), int32(v2.X), int32(v2.Y), raylib.RayWhite)
|
|
raylib.DrawLine(int32(v2.X), int32(v2.Y), int32(v3.X), int32(v3.Y), raylib.RayWhite)
|
|
raylib.DrawLine(int32(v3.X), int32(v3.Y), int32(v4.X), int32(v4.Y), raylib.RayWhite)
|
|
raylib.DrawLine(int32(v4.X), int32(v4.Y), int32(v1.X), int32(v1.Y), raylib.RayWhite)
|
|
}
|
|
|
|
// DrawJoint - Draw joint
|
|
func (g *Game) DrawJoint(j *box2d.Joint) {
|
|
b1 := j.Body1
|
|
b2 := j.Body2
|
|
|
|
R1 := box2d.Mat22ByAngle(b1.Rotation)
|
|
R2 := box2d.Mat22ByAngle(b2.Rotation)
|
|
|
|
x1 := b1.Position
|
|
p1 := x1.Add(R1.MulV(j.LocalAnchor1))
|
|
|
|
x2 := b2.Position
|
|
p2 := x2.Add(R2.MulV(j.LocalAnchor2))
|
|
|
|
o := box2d.Vec2{400, 400}
|
|
S := box2d.Mat22{box2d.Vec2{20.0, 0.0}, box2d.Vec2{0.0, -20.0}}
|
|
|
|
x1 = o.Add(S.MulV(x1))
|
|
p1 = o.Add(S.MulV(p1))
|
|
x2 = o.Add(S.MulV(x2))
|
|
p2 = o.Add(S.MulV(p2))
|
|
|
|
raylib.DrawLine(int32(x1.X), int32(x1.Y), int32(p1.X), int32(p1.Y), raylib.RayWhite)
|
|
raylib.DrawLine(int32(x2.X), int32(x2.Y), int32(p2.X), int32(p2.Y), raylib.RayWhite)
|
|
}
|
|
|
|
// Demo1 - Single box
|
|
func (g *Game) Demo1() {
|
|
g.World.Clear()
|
|
|
|
var b1, b2 box2d.Body
|
|
|
|
b1.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
|
|
b1.Position = box2d.Vec2{0.0, -0.5 * b1.Width.Y}
|
|
g.World.AddBody(&b1)
|
|
|
|
b2.Set(&box2d.Vec2{1.0, 1.0}, 200.0)
|
|
b2.Position = box2d.Vec2{0.0, 4.0}
|
|
g.World.AddBody(&b2)
|
|
}
|
|
|
|
// Demo2 - A simple pendulum
|
|
func (g *Game) Demo2() {
|
|
g.World.Clear()
|
|
|
|
var b2, b1 box2d.Body
|
|
var j box2d.Joint
|
|
|
|
b1.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
|
|
b1.Friction = 0.2
|
|
b1.Position = box2d.Vec2{0.0, -0.5 * b1.Width.Y}
|
|
b1.Rotation = 0.0
|
|
g.World.AddBody(&b1)
|
|
|
|
b2.Set(&box2d.Vec2{1.0, 1.0}, 100.0)
|
|
b2.Friction = 0.2
|
|
b2.Position = box2d.Vec2{9.0, 11.0}
|
|
b2.Rotation = 0.0
|
|
g.World.AddBody(&b2)
|
|
|
|
j.Set(&b1, &b2, &box2d.Vec2{0.0, 11.0})
|
|
g.World.AddJoint(&j)
|
|
}
|
|
|
|
// Demo3 - Varying friction coefficients
|
|
func (g *Game) Demo3() {
|
|
g.World.Clear()
|
|
|
|
{
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
|
|
b.Position = box2d.Vec2{0.0, -0.5 * b.Width.Y}
|
|
g.World.AddBody(&b)
|
|
}
|
|
|
|
{
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{13.0, 0.25}, math.MaxFloat64)
|
|
b.Position = box2d.Vec2{-2.0, 11.0}
|
|
b.Rotation = -0.25
|
|
g.World.AddBody(&b)
|
|
}
|
|
|
|
{
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{0.25, 1.0}, math.MaxFloat64)
|
|
b.Position = box2d.Vec2{5.25, 9.5}
|
|
g.World.AddBody(&b)
|
|
}
|
|
|
|
{
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{13.0, 0.25}, math.MaxFloat64)
|
|
b.Position = box2d.Vec2{2.0, 7.0}
|
|
b.Rotation = 0.25
|
|
g.World.AddBody(&b)
|
|
}
|
|
|
|
{
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{0.25, 1.0}, math.MaxFloat64)
|
|
b.Position = box2d.Vec2{-5.25, 5.5}
|
|
g.World.AddBody(&b)
|
|
}
|
|
|
|
frictions := []float64{0.75, 0.5, 0.35, 0.1, 0.0}
|
|
for i := 0; i < 5; i++ {
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{0.5, 0.5}, 25.0)
|
|
b.Friction = frictions[i]
|
|
b.Position = box2d.Vec2{-7.5 + 2.0*float64(i), 14.0}
|
|
g.World.AddBody(&b)
|
|
}
|
|
|
|
}
|
|
|
|
// Demo4 - A vertical stack
|
|
func (g *Game) Demo4() {
|
|
g.World.Clear()
|
|
|
|
{
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
|
|
b.Friction = 0.2
|
|
b.Position = box2d.Vec2{0.0, -0.5 * b.Width.Y}
|
|
b.Rotation = 0.0
|
|
g.World.AddBody(&b)
|
|
}
|
|
|
|
for i := 0; i < 10; i++ {
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{1.0, 1.0}, 1.0)
|
|
b.Friction = 0.2
|
|
x := rand.Float64()*0.2 - 0.1
|
|
b.Position = box2d.Vec2{x, 0.51 + 1.05*float64(i)}
|
|
g.World.AddBody(&b)
|
|
}
|
|
|
|
}
|
|
|
|
// Demo5 - A pyramid
|
|
func (g *Game) Demo5() {
|
|
g.World.Clear()
|
|
|
|
{
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
|
|
b.Friction = 0.2
|
|
b.Position = box2d.Vec2{0.0, -0.5 * b.Width.Y}
|
|
b.Rotation = 0.0
|
|
g.World.AddBody(&b)
|
|
}
|
|
|
|
x := box2d.Vec2{-6.0, 0.75}
|
|
|
|
for i := 0; i < 12; i++ {
|
|
y := x
|
|
for j := i; j < 12; j++ {
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{1.0, 1.0}, 10.0)
|
|
b.Friction = 0.2
|
|
b.Position = y
|
|
g.World.AddBody(&b)
|
|
|
|
y = y.Add(box2d.Vec2{1.125, 0.0})
|
|
}
|
|
|
|
x = x.Add(box2d.Vec2{0.5625, 2.0})
|
|
}
|
|
}
|
|
|
|
// Demo6 - A teeter
|
|
func (g *Game) Demo6() {
|
|
g.World.Clear()
|
|
|
|
var b1, b2, b3, b4, b5 box2d.Body
|
|
b1.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
|
|
b1.Position = box2d.Vec2{0.0, -0.5 * b1.Width.Y}
|
|
g.World.AddBody(&b1)
|
|
|
|
b2.Set(&box2d.Vec2{12.0, 0.25}, 100)
|
|
b2.Position = box2d.Vec2{0.0, 1.0}
|
|
g.World.AddBody(&b2)
|
|
|
|
b3.Set(&box2d.Vec2{0.5, 0.5}, 25.0)
|
|
b3.Position = box2d.Vec2{-5.0, 2.0}
|
|
g.World.AddBody(&b3)
|
|
|
|
b4.Set(&box2d.Vec2{0.5, 0.5}, 25.0)
|
|
b4.Position = box2d.Vec2{-5.5, 2.0}
|
|
g.World.AddBody(&b4)
|
|
|
|
b5.Set(&box2d.Vec2{1.0, 1.0}, 100)
|
|
b5.Position = box2d.Vec2{5.5, 15.0}
|
|
g.World.AddBody(&b5)
|
|
|
|
{
|
|
var j box2d.Joint
|
|
j.Set(&b1, &b2, &box2d.Vec2{0.0, 1.0})
|
|
g.World.AddJoint(&j)
|
|
}
|
|
|
|
}
|
|
|
|
// Demo7 - A suspension bridge
|
|
func (g *Game) Demo7() {
|
|
g.World.Clear()
|
|
|
|
var ba []*box2d.Body
|
|
|
|
{
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
|
|
b.Friction = 0.2
|
|
b.Position = box2d.Vec2{0.0, -0.5 * b.Width.Y}
|
|
b.Rotation = 0.0
|
|
g.World.AddBody(&b)
|
|
ba = append(ba, &b)
|
|
}
|
|
|
|
const numPlunks = 15
|
|
const mass = 50.0
|
|
|
|
for i := 0; i < numPlunks; i++ {
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{1.0, 0.25}, mass)
|
|
b.Friction = 0.2
|
|
b.Position = box2d.Vec2{-8.5 + 1.25*float64(i), 5.0}
|
|
g.World.AddBody(&b)
|
|
ba = append(ba, &b)
|
|
}
|
|
|
|
// Tuning
|
|
const frequencyHz = 2.0
|
|
const dampingRatio = 0.7
|
|
|
|
// Frequency in radians
|
|
const omega = 2.0 * math.Pi * frequencyHz
|
|
|
|
// Damping coefficient
|
|
const d = 2.0 * mass * dampingRatio * omega
|
|
|
|
// Spring stifness
|
|
const k = mass * omega * omega
|
|
|
|
// Magic formulas
|
|
softness := 1.0 / (d + g.TimeStep*k)
|
|
biasFactor := g.TimeStep * k / (d + g.TimeStep*k)
|
|
|
|
for i := 0; i <= numPlunks; i++ {
|
|
var j box2d.Joint
|
|
j.Set(ba[i], ba[(i+1)%(numPlunks+1)], &box2d.Vec2{-9.125 + 1.25*float64(i), 5.0})
|
|
j.Softness = softness
|
|
j.BiasFactor = biasFactor
|
|
g.World.AddJoint(&j)
|
|
}
|
|
|
|
}
|
|
|
|
// Demo8 - Dominos
|
|
func (g *Game) Demo8() {
|
|
g.World.Clear()
|
|
|
|
var b1 box2d.Body
|
|
b1.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
|
|
b1.Position = box2d.Vec2{0.0, -0.5 * b1.Width.Y}
|
|
g.World.AddBody(&b1)
|
|
|
|
{
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{12.0, 0.5}, math.MaxFloat64)
|
|
b.Position = box2d.Vec2{-1.5, 10.0}
|
|
g.World.AddBody(&b)
|
|
}
|
|
|
|
for i := 0; i < 10; i++ {
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{0.2, 2.0}, 10.0)
|
|
b.Position = box2d.Vec2{-6.0 + 1.0*float64(i), 11.125}
|
|
b.Friction = 0.1
|
|
g.World.AddBody(&b)
|
|
}
|
|
|
|
{
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{14.0, 0.5}, math.MaxFloat64)
|
|
b.Position = box2d.Vec2{1.0, 6.0}
|
|
b.Rotation = 0.3
|
|
g.World.AddBody(&b)
|
|
}
|
|
|
|
var b2 box2d.Body
|
|
b2.Set(&box2d.Vec2{0.5, 3.0}, math.MaxFloat64)
|
|
b2.Position = box2d.Vec2{-7.0, 4.0}
|
|
g.World.AddBody(&b2)
|
|
|
|
var b3 box2d.Body
|
|
b3.Set(&box2d.Vec2{12.0, 0.25}, 20.0)
|
|
b3.Position = box2d.Vec2{-0.9, 1.0}
|
|
g.World.AddBody(&b3)
|
|
|
|
{
|
|
var j box2d.Joint
|
|
j.Set(&b1, &b3, &box2d.Vec2{-2.0, 1.0})
|
|
g.World.AddJoint(&j)
|
|
}
|
|
|
|
var b4 box2d.Body
|
|
b4.Set(&box2d.Vec2{0.5, 0.5}, 10.0)
|
|
b4.Position = box2d.Vec2{-10.0, 15.0}
|
|
g.World.AddBody(&b4)
|
|
|
|
{
|
|
var j box2d.Joint
|
|
j.Set(&b2, &b4, &box2d.Vec2{-7.0, 15.0})
|
|
g.World.AddJoint(&j)
|
|
}
|
|
|
|
var b5 box2d.Body
|
|
b5.Set(&box2d.Vec2{2.0, 2.0}, 20.0)
|
|
b5.Position = box2d.Vec2{6.0, 2.5}
|
|
b5.Friction = 0.1
|
|
g.World.AddBody(&b5)
|
|
|
|
{
|
|
var j box2d.Joint
|
|
j.Set(&b1, &b5, &box2d.Vec2{6.0, 2.6})
|
|
g.World.AddJoint(&j)
|
|
}
|
|
|
|
var b6 box2d.Body
|
|
b6.Set(&box2d.Vec2{2.0, 0.2}, 10.0)
|
|
b6.Position = box2d.Vec2{6.0, 3.6}
|
|
g.World.AddBody(&b6)
|
|
|
|
{
|
|
var j box2d.Joint
|
|
j.Set(&b5, &b6, &box2d.Vec2{7.0, 3.5})
|
|
g.World.AddJoint(&j)
|
|
}
|
|
|
|
}
|
|
|
|
// Demo9 - A multi-pendulum
|
|
func (g *Game) Demo9() {
|
|
g.World.Clear()
|
|
|
|
var b1 *box2d.Body
|
|
|
|
{
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{100.0, 20.0}, math.MaxFloat64)
|
|
b.Position = box2d.Vec2{0.0, -0.5 * b.Width.Y}
|
|
g.World.AddBody(&b)
|
|
b1 = &b
|
|
}
|
|
|
|
const mass = 10.0
|
|
|
|
// Tuning
|
|
const frequencyHz = 4.0
|
|
const dampingRatio = 0.7
|
|
|
|
// Frequency in radians
|
|
const omega = 2.0 * math.Pi * frequencyHz
|
|
|
|
// Damping coefficient
|
|
const d = 2.0 * mass * dampingRatio * omega
|
|
|
|
// Spring stiffness
|
|
const k = mass * omega * omega
|
|
|
|
// Magic formulas
|
|
softness := 1.0 / (d + g.TimeStep*k)
|
|
biasFactor := g.TimeStep * k / (d + g.TimeStep*k)
|
|
|
|
const y = 12.0
|
|
|
|
for i := 0; i < 15; i++ {
|
|
x := box2d.Vec2{0.5 + float64(i), y}
|
|
|
|
var b box2d.Body
|
|
b.Set(&box2d.Vec2{0.75, 0.25}, mass)
|
|
b.Friction = 0.2
|
|
b.Position = x
|
|
b.Rotation = 0.0
|
|
g.World.AddBody(&b)
|
|
|
|
var j box2d.Joint
|
|
j.Set(b1, &b, &box2d.Vec2{float64(i), y})
|
|
j.Softness = softness
|
|
j.BiasFactor = biasFactor
|
|
g.World.AddJoint(&j)
|
|
|
|
b1 = &b
|
|
}
|
|
|
|
}
|
|
|
|
func main() {
|
|
raylib.InitWindow(800, 450, "raylib [physics] example - box2d")
|
|
|
|
raylib.SetTargetFPS(60)
|
|
|
|
game := NewGame()
|
|
|
|
game.Demo1()
|
|
|
|
for !raylib.WindowShouldClose() {
|
|
raylib.BeginDrawing()
|
|
|
|
raylib.ClearBackground(raylib.Black)
|
|
|
|
game.Update()
|
|
|
|
game.Draw()
|
|
|
|
raylib.EndDrawing()
|
|
}
|
|
|
|
raylib.CloseWindow()
|
|
}
|