func (*DefaultScene) Setup(w *ecs.World) {
engo.SetBackground(color.White)
w.AddSystem(&engo.RenderSystem{})
// Retrieve a texture
texture := engo.Files.Image("icon.png")
// Create an entity
guy := Guy{BasicEntity: ecs.NewBasic()}
// Initialize the components, set scale to 8x
guy.RenderComponent = engo.RenderComponent{
Drawable: texture,
Scale: engo.Point{8, 8},
}
guy.SpaceComponent = engo.SpaceComponent{
Position: engo.Point{0, 0},
Width: texture.Width() * guy.RenderComponent.Scale.X,
Height: texture.Height() * guy.RenderComponent.Scale.Y,
}
// Add it to appropriate systems
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&guy.BasicEntity, &guy.RenderComponent, &guy.SpaceComponent)
}
}
}
func NewRock(world *ecs.World, position engo.Point) {
texture := engo.Files.Image("rock.png")
rock := Rock{BasicEntity: ecs.NewBasic()}
rock.RenderComponent = engo.RenderComponent{
Drawable: texture,
Scale: engo.Point{4, 4},
}
rock.SpaceComponent = engo.SpaceComponent{
Position: position,
Width: texture.Width() * rock.RenderComponent.Scale.X,
Height: texture.Height() * rock.RenderComponent.Scale.Y,
}
rock.CollisionComponent = engo.CollisionComponent{Solid: true}
for _, system := range world.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&rock.BasicEntity, &rock.RenderComponent, &rock.SpaceComponent)
case *engo.CollisionSystem:
sys.Add(&rock.BasicEntity, &rock.CollisionComponent, &rock.SpaceComponent)
case *FallingSystem:
sys.Add(&rock.BasicEntity, &rock.SpaceComponent)
}
}
}
func (*DefaultScene) Setup(w *ecs.World) {
w.AddSystem(&engo.RenderSystem{})
w.AddSystem(&InputSystem{})
engo.Input.RegisterAxis("sideways", engo.AxisKeyPair{engo.A, engo.D})
engo.Input.RegisterButton("action", engo.Space, engo.Enter)
}
// Setup is called before the main loop is started
func (*DefaultScene) Setup(w *ecs.World) {
engo.SetBackground(color.White)
w.AddSystem(&engo.RenderSystem{})
w.AddSystem(&engo.MouseZoomer{zoomSpeed})
// Create the background; this way we'll see when we actually zoom
demoutils.NewBackground(w, worldWidth, worldHeight, color.RGBA{102, 153, 0, 255}, color.RGBA{102, 173, 0, 255})
}
// Setup is called before the main loop is started
func (*DefaultScene) Setup(w *ecs.World) {
engo.SetBackground(color.White)
w.AddSystem(&engo.RenderSystem{})
// The most important line in this whole demo:
w.AddSystem(&engo.EdgeScroller{scrollSpeed, edgeMargin})
// Create the background; this way we'll see when we actually scroll
demoutils.NewBackground(w, worldWidth, worldHeight, color.RGBA{102, 153, 0, 255}, color.RGBA{102, 173, 0, 255})
}
// Setup is called before the main loop is started
func (*DefaultScene) Setup(w *ecs.World) {
engo.SetBackground(color.White)
w.AddSystem(&engo.RenderSystem{})
// The most important line in this whole demo:
w.AddSystem(engo.NewKeyboardScroller(scrollSpeed, engo.DefaultHorizontalAxis, engo.DefaultVerticalAxis))
// Create the background; this way we'll see when we actually scroll
demoutils.NewBackground(w, worldWidth, worldHeight, color.RGBA{102, 153, 0, 255}, color.RGBA{102, 173, 0, 255})
}
func (c *ControlSystem) New(w *ecs.World) {
c.mouseTrackerBasic = ecs.NewBasic()
c.mouseTrackerMouse.Track = true
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.MouseSystem:
sys.Add(&c.mouseTrackerBasic, &c.mouseTrackerMouse, nil, nil)
}
}
}
// Setup is called before the main loop is started
func (*DefaultScene) Setup(w *ecs.World) {
engo.SetBackground(color.White)
w.AddSystem(&engo.RenderSystem{})
w.AddSystem(&engo.MouseRotator{RotationSpeed: rotationSpeed})
// Create a background; this way we'll see when we actually rotate
demoutils.NewBackground(w, 300, worldHeight, color.RGBA{102, 153, 0, 255}, color.RGBA{102, 173, 0, 255})
// Create a background; this way we'll see when we actually rotate
bg2 := demoutils.NewBackground(w, 300, worldHeight, color.RGBA{102, 153, 0, 255}, color.RGBA{102, 173, 0, 255})
bg2.SpaceComponent.Position.X = 500
}
func (game *RockScene) Setup(w *ecs.World) {
engo.SetBackground(color.White)
w.AddSystem(&engo.RenderSystem{})
w.AddSystem(&ScaleSystem{})
w.AddSystem(&SceneSwitcherSystem{NextScene: "IconScene", WaitTime: time.Second * 3})
// Retrieve a texture
texture := engo.Files.Image("rock.png")
// Create an entity
rock := Rock{BasicEntity: ecs.NewBasic()}
// Initialize the components, set scale to 8x
rock.RenderComponent = engo.RenderComponent{
Drawable: texture,
Scale: engo.Point{8, 8},
}
rock.SpaceComponent = engo.SpaceComponent{
Position: engo.Point{0, 0},
Width: texture.Width() * rock.RenderComponent.Scale.X,
Height: texture.Height() * rock.RenderComponent.Scale.Y,
}
// Add it to appropriate systems
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&rock.BasicEntity, &rock.RenderComponent, &rock.SpaceComponent)
case *ScaleSystem:
sys.Add(&rock.BasicEntity, &rock.RenderComponent)
}
}
}
// Setup is called before the main loop is started
func (*DefaultScene) Setup(w *ecs.World) {
engo.SetBackground(color.White)
w.AddSystem(&engo.RenderSystem{})
demoutils.NewBackground(w, worldWidth, worldHeight, color.RGBA{102, 153, 0, 255}, color.RGBA{102, 173, 0, 255})
// We issue one camera zoom command at the start, but it takes a while to process because we set a duration
engo.Mailbox.Dispatch(engo.CameraMessage{
Axis: engo.ZAxis,
Value: 3, // so zooming out a lot
Incremental: true,
Duration: time.Second * 5,
})
}
// NewBackground creates a background of colored tiles - might not be the most efficient way to do this
// It gets added to the world as well, so we won't return anything.
func NewBackground(world *ecs.World, width, height int, colorA, colorB color.Color) *Background {
rect := image.Rect(0, 0, width, height)
img := image.NewNRGBA(rect)
for i := rect.Min.X; i < rect.Max.X; i++ {
for j := rect.Min.Y; j < rect.Max.Y; j++ {
if i%40 > 20 {
if j%40 > 20 {
img.Set(i, j, colorA)
} else {
img.Set(i, j, colorB)
}
} else {
if j%40 > 20 {
img.Set(i, j, colorB)
} else {
img.Set(i, j, colorA)
}
}
}
}
bgTexture := engo.NewImageObject(img)
bg := &Background{BasicEntity: ecs.NewBasic()}
bg.RenderComponent = engo.RenderComponent{Drawable: engo.NewTexture(bgTexture)}
bg.SpaceComponent = engo.SpaceComponent{
Position: engo.Point{0, 0},
Width: float32(width),
Height: float32(height),
}
for _, system := range world.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&bg.BasicEntity, &bg.RenderComponent, &bg.SpaceComponent)
}
}
return bg
}
func (scene *DefaultScene) Setup(w *ecs.World) {
engo.SetBackground(color.White)
w.AddSystem(&engo.RenderSystem{})
w.AddSystem(&engo.AnimationSystem{})
w.AddSystem(&ControlSystem{})
spriteSheet := engo.NewSpritesheetFromFile("hero.png", 150, 150)
hero := scene.CreateEntity(&engo.Point{0, 0}, spriteSheet)
// Add our hero to the appropriate systems
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&hero.BasicEntity, &hero.RenderComponent, &hero.SpaceComponent)
case *engo.AnimationSystem:
sys.Add(&hero.BasicEntity, &hero.AnimationComponent, &hero.RenderComponent)
case *ControlSystem:
sys.Add(&hero.BasicEntity, &hero.AnimationComponent)
}
}
}
func (*DefaultScene) Setup(w *ecs.World) {
engo.SetBackground(color.White)
w.AddSystem(&engo.AudioSystem{})
w.AddSystem(&WhoopSystem{})
whoop := Whoop{BasicEntity: ecs.NewBasic()}
whoop.AudioComponent = engo.AudioComponent{File: "326488.wav", Repeat: true, Background: true, RawVolume: 1}
// Let's add our whoop to the appropriate systems
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.AudioSystem:
// Note we are giving a `nil` reference to the `SpeedComponent`. This is because the documentation of the
// AudioSystem says the `SpeedComponent` is only required when `AudioComponent.Background` is `false`.
// In our case, it is `true` (it's a background noise, i.e. not tied to a location in the game world),
// so we can omit it.
sys.Add(&whoop.BasicEntity, &whoop.AudioComponent, nil)
}
}
}
// Setup is called before the main loop is started
func (*DefaultScene) Setup(w *ecs.World) {
engo.SetBackground(color.White)
w.AddSystem(&engo.RenderSystem{})
// Adding KeyboardScroller so we can actually see the difference between background and HUD when scrolling
w.AddSystem(engo.NewKeyboardScroller(scrollSpeed, engo.DefaultHorizontalAxis, engo.DefaultVerticalAxis))
w.AddSystem(&engo.MouseZoomer{zoomSpeed})
// Create background, so we can see difference between this and HUD
demoutils.NewBackground(w, worldWidth, worldHeight, color.RGBA{102, 153, 0, 255}, color.RGBA{102, 173, 0, 255})
// Define parameters for the hud
hudWidth := 200 // Can be anything you want
hudHeight := int(engo.WindowHeight()) // Can be anything you want
// Generate something that uses the PriorityLevel HUDGround or up. We're giving the same color twice,
// so it'll create one solid color.
hudBg := demoutils.NewBackground(w, hudWidth, hudHeight, color.RGBA{255, 0, 255, 180}, color.RGBA{255, 0, 255, 180})
// These adjustments are needed to transform it into a HUD:
hudBg.RenderComponent.SetZIndex(1) // something bigger than default (0), so it'll be on top of the regular background
hudBg.RenderComponent.SetShader(engo.HUDShader)
}
func (pong *PongGame) Setup(w *ecs.World) {
engo.SetBackground(color.Black)
w.AddSystem(&engo.RenderSystem{})
w.AddSystem(&engo.CollisionSystem{})
w.AddSystem(&engo.MouseSystem{})
w.AddSystem(&SpeedSystem{})
w.AddSystem(&ControlSystem{})
w.AddSystem(&BounceSystem{})
w.AddSystem(&ScoreSystem{})
basicFont = (&engo.Font{URL: "Roboto-Regular.ttf", Size: 32, FG: color.NRGBA{255, 255, 255, 255}})
if err := basicFont.CreatePreloaded(); err != nil {
log.Fatalln("Could not load font:", err)
}
ballTexture := engo.Files.Image("ball.png")
ball := Ball{BasicEntity: ecs.NewBasic()}
ball.RenderComponent = engo.RenderComponent{
Drawable: ballTexture,
Scale: engo.Point{2, 2},
}
ball.SpaceComponent = engo.SpaceComponent{
Position: engo.Point{(engo.GameWidth() - ballTexture.Width()) / 2, (engo.GameHeight() - ballTexture.Height()) / 2},
Width: ballTexture.Width() * ball.RenderComponent.Scale.X,
Height: ballTexture.Height() * ball.RenderComponent.Scale.Y,
}
ball.CollisionComponent = engo.CollisionComponent{
Main: true,
Solid: true,
}
ball.SpeedComponent = SpeedComponent{Point: engo.Point{300, 1000}}
// Add our entity to the appropriate systems
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&ball.BasicEntity, &ball.RenderComponent, &ball.SpaceComponent)
case *engo.CollisionSystem:
sys.Add(&ball.BasicEntity, &ball.CollisionComponent, &ball.SpaceComponent)
case *SpeedSystem:
sys.Add(&ball.BasicEntity, &ball.SpeedComponent, &ball.SpaceComponent)
case *BounceSystem:
sys.Add(&ball.BasicEntity, &ball.SpeedComponent, &ball.SpaceComponent)
}
}
score := Score{BasicEntity: ecs.NewBasic()}
score.RenderComponent = engo.RenderComponent{Drawable: basicFont.Render(" ")}
score.SpaceComponent = engo.SpaceComponent{
Position: engo.Point{100, 100},
Width: 100,
Height: 100,
}
// Add our entity to the appropriate systems
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&score.BasicEntity, &score.RenderComponent, &score.SpaceComponent)
case *ScoreSystem:
sys.Add(&score.BasicEntity, &score.RenderComponent, &score.SpaceComponent)
}
}
engo.Input.RegisterAxis("wasd", engo.AxisKeyPair{engo.W, engo.S})
engo.Input.RegisterAxis("arrows", engo.AxisKeyPair{engo.ArrowUp, engo.ArrowDown})
schemes := []string{"wasd", "arrows"}
score.RenderComponent = engo.RenderComponent{Drawable: basicFont.Render(" ")}
score.SpaceComponent = engo.SpaceComponent{
Position: engo.Point{100, 100},
Width: 100,
Height: 100,
}
// Add our entity to the appropriate systems
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&score.BasicEntity, &score.RenderComponent, &score.SpaceComponent)
case *ScoreSystem:
sys.Add(&score.BasicEntity, &score.RenderComponent, &score.SpaceComponent)
}
}
paddleTexture := engo.Files.Image("paddle.png")
for i := 0; i < 2; i++ {
paddle := Paddle{BasicEntity: ecs.NewBasic()}
paddle.RenderComponent = engo.RenderComponent{
Drawable: paddleTexture,
Scale: engo.Point{2, 2},
}
x := float32(0)
if i != 0 {
x = 800 - 16
}
paddle.SpaceComponent = engo.SpaceComponent{
Position: engo.Point{x, (engo.GameHeight() - paddleTexture.Height()) / 2},
Width: paddle.RenderComponent.Scale.X * paddleTexture.Width(),
Height: paddle.RenderComponent.Scale.Y * paddleTexture.Height(),
}
paddle.ControlComponent = ControlComponent{Scheme: schemes[i]}
paddle.CollisionComponent = engo.CollisionComponent{
Main: false,
Solid: true,
}
// Add our entity to the appropriate systems
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&paddle.BasicEntity, &paddle.RenderComponent, &paddle.SpaceComponent)
case *engo.CollisionSystem:
sys.Add(&paddle.BasicEntity, &paddle.CollisionComponent, &paddle.SpaceComponent)
case *ControlSystem:
sys.Add(&paddle.BasicEntity, &paddle.ControlComponent, &paddle.SpaceComponent)
}
}
}
}
func (*DefaultScene) Setup(w *ecs.World) {
w.AddSystem(&engo.RenderSystem{})
}
// Setup is called before the main loop is started
func (*DefaultScene) Setup(w *ecs.World) {
engo.SetBackground(color.RGBA{55, 55, 55, 255})
w.AddSystem(&engo.RenderSystem{})
// Adding camera controllers so we can verify it doesn't break when we move
w.AddSystem(engo.NewKeyboardScroller(scrollSpeed, engo.DefaultHorizontalAxis, engo.DefaultVerticalAxis))
w.AddSystem(&engo.MouseZoomer{zoomSpeed})
w.AddSystem(&engo.MouseRotator{RotationSpeed: 0.125})
triangle1 := MyShape{BasicEntity: ecs.NewBasic()}
triangle1.SpaceComponent = engo.SpaceComponent{Width: 100, Height: 100}
triangle1.RenderComponent = engo.RenderComponent{Drawable: engo.Triangle{}, Color: color.RGBA{255, 0, 0, 255}}
triangle1.RenderComponent.SetShader(engo.LegacyShader)
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&triangle1.BasicEntity, &triangle1.RenderComponent, &triangle1.SpaceComponent)
}
}
rectangle1 := MyShape{BasicEntity: ecs.NewBasic()}
rectangle1.SpaceComponent = engo.SpaceComponent{Position: engo.Point{100, 100}, Width: 100, Height: 100}
rectangle1.RenderComponent = engo.RenderComponent{Drawable: engo.Rectangle{}, Color: color.RGBA{0, 255, 0, 255}}
rectangle1.RenderComponent.SetShader(engo.LegacyShader)
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&rectangle1.BasicEntity, &rectangle1.RenderComponent, &rectangle1.SpaceComponent)
}
}
circle1 := MyShape{BasicEntity: ecs.NewBasic()}
circle1.SpaceComponent = engo.SpaceComponent{Position: engo.Point{200, 200}, Width: 100, Height: 100}
circle1.RenderComponent = engo.RenderComponent{Drawable: engo.Circle{}, Color: color.RGBA{0, 0, 255, 255}}
circle1.RenderComponent.SetShader(engo.LegacyShader)
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&circle1.BasicEntity, &circle1.RenderComponent, &circle1.SpaceComponent)
}
}
triangle2 := MyShape{BasicEntity: ecs.NewBasic()}
triangle2.SpaceComponent = engo.SpaceComponent{Position: engo.Point{300, 300}, Width: 100, Height: 100}
triangle2.RenderComponent = engo.RenderComponent{Drawable: engo.Triangle{TriangleType: engo.TriangleRight}, Color: color.RGBA{255, 255, 0, 255}}
triangle2.RenderComponent.SetShader(engo.LegacyShader)
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&triangle2.BasicEntity, &triangle2.RenderComponent, &triangle2.SpaceComponent)
}
}
line1 := MyShape{BasicEntity: ecs.NewBasic()}
line1.SpaceComponent = engo.SpaceComponent{Position: engo.Point{400, 400}, Width: 1, Height: 100}
line1.RenderComponent = engo.RenderComponent{Drawable: engo.Rectangle{}, Color: color.RGBA{0, 255, 255, 255}}
line1.RenderComponent.SetShader(engo.LegacyShader)
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&line1.BasicEntity, &line1.RenderComponent, &line1.SpaceComponent)
}
}
complexTriangle1 := MyShape{BasicEntity: ecs.NewBasic()}
complexTriangle1.SpaceComponent = engo.SpaceComponent{Position: engo.Point{500, 500}, Width: 100, Height: 100}
complexTriangle1.RenderComponent = engo.RenderComponent{Drawable: engo.ComplexTriangles{
Points: []engo.Point{
{0.0, 0.0}, {1.0, 0.25}, {0.5, 0.5},
{0.5, 0.5}, {1.0, 0.75}, {0.0, 1.0},
{0.0, 0.0}, {0.5, 0.50}, {0.0, 1.0},
}}, Color: color.RGBA{255, 0, 255, 255}}
complexTriangle1.RenderComponent.SetShader(engo.LegacyShader)
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&complexTriangle1.BasicEntity, &complexTriangle1.RenderComponent, &complexTriangle1.SpaceComponent)
}
}
triangle3 := MyShape{BasicEntity: ecs.NewBasic()}
triangle3.SpaceComponent = engo.SpaceComponent{Position: engo.Point{23, 123}, Width: 50, Height: 50}
triangle3.RenderComponent = engo.RenderComponent{Drawable: engo.Triangle{BorderWidth: 1, BorderColor: color.White}, Color: color.RGBA{255, 0, 0, 255}}
triangle3.RenderComponent.SetShader(engo.LegacyShader)
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&triangle3.BasicEntity, &triangle3.RenderComponent, &triangle3.SpaceComponent)
}
}
rectangle2 := MyShape{BasicEntity: ecs.NewBasic()}
rectangle2.SpaceComponent = engo.SpaceComponent{Position: engo.Point{123, 223}, Width: 50, Height: 50}
rectangle2.RenderComponent = engo.RenderComponent{Drawable: engo.Rectangle{BorderWidth: 1, BorderColor: color.White}, Color: color.RGBA{0, 255, 0, 255}}
rectangle2.RenderComponent.SetShader(engo.LegacyShader)
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&rectangle2.BasicEntity, &rectangle2.RenderComponent, &rectangle2.SpaceComponent)
}
}
circle2 := MyShape{BasicEntity: ecs.NewBasic()}
circle2.SpaceComponent = engo.SpaceComponent{Position: engo.Point{223, 323}, Width: 50, Height: 50}
circle2.RenderComponent = engo.RenderComponent{Drawable: engo.Circle{BorderWidth: 1, BorderColor: color.White}, Color: color.RGBA{0, 0, 255, 255}}
circle2.RenderComponent.SetShader(engo.LegacyShader)
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&circle2.BasicEntity, &circle2.RenderComponent, &circle2.SpaceComponent)
}
}
triangle4 := MyShape{BasicEntity: ecs.NewBasic()}
triangle4.SpaceComponent = engo.SpaceComponent{Position: engo.Point{323, 423}, Width: 50, Height: 50}
triangle4.RenderComponent = engo.RenderComponent{Drawable: engo.Triangle{TriangleType: engo.TriangleRight, BorderWidth: 1, BorderColor: color.White}, Color: color.RGBA{255, 255, 0, 255}}
triangle4.RenderComponent.SetShader(engo.LegacyShader)
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&triangle4.BasicEntity, &triangle4.RenderComponent, &triangle4.SpaceComponent)
}
}
complexTriangle2 := MyShape{BasicEntity: ecs.NewBasic()}
complexTriangle2.SpaceComponent = engo.SpaceComponent{Position: engo.Point{523, 623}, Width: 50, Height: 50}
complexTriangle2.RenderComponent = engo.RenderComponent{Drawable: engo.ComplexTriangles{
BorderWidth: 1, BorderColor: color.White,
Points: []engo.Point{
{0.0, 0.0}, {1.0, 0.25}, {0.5, 0.5},
{0.5, 0.5}, {1.0, 0.75}, {0.0, 1.0},
{0.0, 0.0}, {0.5, 0.50}, {0.0, 1.0},
}}, Color: color.RGBA{255, 0, 255, 255}}
complexTriangle2.RenderComponent.SetShader(engo.LegacyShader)
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&complexTriangle2.BasicEntity, &complexTriangle2.RenderComponent, &complexTriangle2.SpaceComponent)
}
}
}
func (*DefaultScene) Setup(w *ecs.World) {
engo.SetBackground(color.White)
// Add all of the systems
w.AddSystem(&engo.RenderSystem{})
w.AddSystem(&engo.CollisionSystem{})
w.AddSystem(&DeathSystem{})
w.AddSystem(&FallingSystem{})
w.AddSystem(&ControlSystem{})
w.AddSystem(&RockSpawnSystem{})
texture := engo.Files.Image("icon.png")
// Create an entity
guy := Guy{BasicEntity: ecs.NewBasic()}
// Initialize the components, set scale to 4x
guy.RenderComponent = engo.RenderComponent{
Drawable: texture,
Scale: engo.Point{4, 4},
}
guy.SpaceComponent = engo.SpaceComponent{
Position: engo.Point{0, 0},
Width: texture.Width() * guy.RenderComponent.Scale.X,
Height: texture.Height() * guy.RenderComponent.Scale.Y,
}
guy.CollisionComponent = engo.CollisionComponent{
Solid: true,
Main: true,
}
// Add it to appropriate systems
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&guy.BasicEntity, &guy.RenderComponent, &guy.SpaceComponent)
case *engo.CollisionSystem:
sys.Add(&guy.BasicEntity, &guy.CollisionComponent, &guy.SpaceComponent)
case *ControlSystem:
sys.Add(&guy.BasicEntity, &guy.SpaceComponent)
}
}
}
func (*DefaultScene) Setup(w *ecs.World) {
engo.SetBackground(color.White)
w.AddSystem(&engo.MouseSystem{})
w.AddSystem(&engo.RenderSystem{})
w.AddSystem(&ControlSystem{})
// These are not required, but allow you to move / rotate and still see that it works
w.AddSystem(&engo.MouseZoomer{-0.125})
w.AddSystem(engo.NewKeyboardScroller(500, engo.DefaultHorizontalAxis, engo.DefaultVerticalAxis))
w.AddSystem(&engo.MouseRotator{RotationSpeed: 0.125})
// Retrieve a texture
texture := engo.Files.Image("icon.png")
// Create an entity
guy := Guy{BasicEntity: ecs.NewBasic()}
// Initialize the components, set scale to 8x
guy.RenderComponent = engo.RenderComponent{
Drawable: texture,
Scale: engo.Point{8, 8},
}
guy.SpaceComponent = engo.SpaceComponent{
Position: engo.Point{200, 200},
Width: texture.Width() * guy.RenderComponent.Scale.X,
Height: texture.Height() * guy.RenderComponent.Scale.Y,
Rotation: 90,
}
// guy.MouseComponent doesn't have to be set, because its default values will do
// Add our guy to appropriate systems
for _, system := range w.Systems() {
switch sys := system.(type) {
case *engo.RenderSystem:
sys.Add(&guy.BasicEntity, &guy.RenderComponent, &guy.SpaceComponent)
case *engo.MouseSystem:
sys.Add(&guy.BasicEntity, &guy.MouseComponent, &guy.SpaceComponent, &guy.RenderComponent)
case *ControlSystem:
sys.Add(&guy.BasicEntity, &guy.MouseComponent)
}
}
}