func onStart(glctx gl.Context, u *uistate.UIState) {
flag.Set("v23.credentials", "/sdcard/credentials")
vlog.Log.Configure(vlog.OverridePriorConfiguration(true), vlog.LogToStderr(true))
vlog.Log.Configure(vlog.OverridePriorConfiguration(true), vlog.Level(0))
ctx, shutdown := v23.Init()
u.Shutdown = shutdown
u.Ctx = ctx
u.Service = syncbase.NewService(util.MountPoint + "/croupier/" + util.SBName)
namespace := v23.GetNamespace(u.Ctx)
allAccess := access.AccessList{In: []security.BlessingPattern{"..."}}
permissions := access.Permissions{
"Admin": allAccess,
"Write": allAccess,
"Read": allAccess,
"Resolve": allAccess,
"Debug": allAccess,
}
namespace.SetPermissions(u.Ctx, util.MountPoint, permissions, "")
namespace.SetPermissions(u.Ctx, util.MountPoint+"/croupier", permissions, "")
u.Service.SetPermissions(u.Ctx, permissions, "")
u.Images = glutil.NewImages(glctx)
fps = debug.NewFPS(u.Images)
u.Eng = glsprite.Engine(u.Images)
u.Texs = texture.LoadTextures(u.Eng)
u.CurTable = table.InitializeGame(u.NumPlayers, u.Texs)
sound.InitPlayers(u)
sync.CreateTables(u)
// Create watch stream to update game state based on Syncbase updates
go sync.UpdateSettings(u)
}
// Testing full image adjustment after screen resizing (assumes adjustImgs is scaling dimensions)
func TestThree(test *testing.T) {
u = uistate.MakeUIState()
u.Scene = &sprite.Node{}
u.Eng = glsprite.Engine(nil)
u.Eng.Register(u.Scene)
u.Eng.SetTransform(u.Scene, f32.Affine{
{1, 0, 0},
{0, 1, 0},
})
imgPos := coords.MakeVec(5, 20)
imgDimensions := coords.MakeVec(10, 10)
newButton := texture.MakeImgWithoutAlt(subtex, imgPos, imgDimensions, u)
u.Buttons["1"] = newButton
oldWindow := u.WindowSize.DividedBy(2)
resize.AdjustImgs(oldWindow, u)
newPos := u.Buttons["1"].GetCurrent()
newDimensions := u.Buttons["1"].GetDimensions()
dimExpect := imgDimensions.Times(2)
posExpect := imgPos.Times(2)
if newDimensions.X != dimExpect.X {
test.Errorf("Expected width %f, got %f", dimExpect.X, newDimensions.X)
}
if newDimensions.Y != dimExpect.Y {
test.Errorf("Expected height %f, got %f", dimExpect.Y, newDimensions.Y)
}
if newPos.X != posExpect.X {
test.Errorf("Expected x %f, got %f", posExpect.X, newPos.X)
}
if newPos.Y != posExpect.Y {
test.Errorf("Expected y %f, got %f", posExpect.Y, newPos.Y)
}
}
func main() {
app.Main(func(a app.App) {
var c event.Config
var eng *WritableEngine
var root *sprite.Node
startClock := time.Now()
for e := range a.Events() {
switch e := event.Filter(e).(type) {
case event.Config:
c = e
case event.Draw:
if eng == nil || root == nil {
eng = NewWritableEngine(
glsprite.Engine(),
image.Rect(0, 0, int(c.Width.Px(c.PixelsPerPt)), int(c.Height.Px(c.PixelsPerPt))),
color.White,
)
root = loadScene(eng, loadTextures(eng))
go listen(eng, ":8080")
}
now := clock.Time(time.Since(startClock) * 60 / time.Second)
gl.ClearColor(1, 1, 1, 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
gl.Enable(gl.BLEND)
gl.BlendEquation(gl.FUNC_ADD)
gl.BlendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA)
if eng != nil && root != nil {
eng.Render(root, now, c)
}
a.EndDraw()
}
}
})
}
// Testing NewImgWithAlt
func TestFive(test *testing.T) {
scene := &sprite.Node{}
eng := glsprite.Engine(nil)
u.Eng = eng
u.Scene = scene
pos := coords.MakeVec(5, 10)
dimensions := coords.MakeVec(20, 10)
i := texture.MakeImgWithAlt(subtex, subtex, pos, dimensions, true, u)
if i.GetCurrent().X != pos.X {
test.Errorf("Expected x %f, got %f", pos.X, i.GetCurrent().X)
}
if i.GetCurrent().Y != pos.Y {
test.Errorf("Expected y %f, got %f", pos.Y, i.GetCurrent().Y)
}
if i.GetInitial().X != pos.X {
test.Errorf("Expected inital x %f, got %f", pos.X, i.GetInitial().X)
}
if i.GetInitial().Y != pos.Y {
test.Errorf("Expected initial y %f, got %f", pos.Y, i.GetInitial().Y)
}
if i.GetDimensions().X != dimensions.X {
test.Errorf("Expected width %f, got %f", dimensions.X, i.GetDimensions().X)
}
if i.GetDimensions().Y != dimensions.Y {
test.Errorf("Expected height %f, got %f", dimensions.Y, i.GetDimensions().Y)
}
}
func onStart(glctx gl.Context, sz size.Event) {
images = glutil.NewImages(glctx)
eng = glsprite.Engine(images)
log = gmlog.New(images, 5)
bbot = NewApp()
bbot.Reset(sz)
scene = bbot.Scene(eng, sz)
}
// Testing resetting card position
func TestSix(test *testing.T) {
u = uistate.MakeUIState()
u.Scene = &sprite.Node{}
u.Eng = glsprite.Engine(nil)
u.Eng.Register(u.Scene)
u.Eng.SetTransform(u.Scene, f32.Affine{
{1, 0, 0},
{0, 1, 0},
})
u.EmptySuitImgs = []*staticimg.StaticImg{staticimg.MakeStaticImg(), staticimg.MakeStaticImg(), staticimg.MakeStaticImg(), staticimg.MakeStaticImg()}
u.WindowSize = windowSize
n := texture.MakeNode(u)
for _, e := range u.EmptySuitImgs {
e.SetImage(subtex)
e.SetAlt(subtex)
e.SetNode(n)
}
c := card.NewCard(card.Two, card.Heart)
c2 := card.NewCard(card.Four, card.Heart)
n = texture.MakeNode(u)
n2 := texture.MakeNode(u)
initialXY := coords.MakeVec(10, 10)
curXY := coords.MakeVec(100, 30)
dimensions := coords.MakeVec(5, 5)
c.SetNode(n)
c2.SetNode(n2)
c.SetInitial(initialXY)
c2.SetInitial(initialXY)
c.Move(curXY, dimensions, u.Eng)
c2.Move(curXY, dimensions, u.Eng)
u.Cards = append(u.Cards, c)
u.Cards = append(u.Cards, c2)
if c.GetCurrent().X != curXY.X {
test.Errorf("Expected x %f, got %f", curXY.X, c.GetCurrent().X)
}
if c.GetCurrent().Y != curXY.Y {
test.Errorf("Expected y %f, got %f", curXY.Y, c.GetCurrent().Y)
}
reposition.ResetCardPosition(c, u.Eng)
reposition.ResetCardPosition(c2, u.Eng)
reposition.RealignSuit(c.GetSuit(), c.GetInitial().Y, u)
if c.GetCurrent().X != u.Padding {
test.Errorf("Expected x %f, got %f", initialXY.X, c.GetCurrent().X)
}
if c.GetCurrent().Y != initialXY.Y {
test.Errorf("Expected y %f, got %f", initialXY.Y, c.GetCurrent().Y)
}
if c2.GetCurrent().X != u.Padding+dimensions.X+u.Padding {
test.Errorf("Expected x %f, got %f", u.Padding+dimensions.X+u.Padding, c2.GetCurrent().X)
}
if c2.GetCurrent().Y != initialXY.Y {
test.Errorf("Expected y %f, got %f", initialXY.Y, c2.GetCurrent().Y)
}
}
func (self *GLPeer) initEng() {
if self.eng != nil {
self.eng.Release()
}
self.eng = glsprite.Engine(self.images)
self.scene = &sprite.Node{}
self.eng.Register(self.scene)
self.eng.SetTransform(self.scene, f32.Affine{
{1, 0, 0},
{0, 1, 0},
})
}
func onPaint(sz size.Event) {
if scene == nil {
images = glutil.NewImages()
fps = debug.NewFPS(images)
eng = glsprite.Engine(images)
loadScene()
}
gl.ClearColor(1, 1, 1, 1)
gl.Clear(gl.COLOR_BUFFER_BIT)
now := clock.Time(time.Since(startTime) * 60 / time.Second)
eng.Render(scene, now, sz)
fps.Draw(sz)
}
func onStart(glctx gl.Context) {
images = glutil.NewImages(glctx)
eng = glsprite.Engine(images)
loadScene()
rc, err := asset.Open("boing.wav")
if err != nil {
log.Fatal(err)
}
player, err = audio.NewPlayer(rc, 0, 0)
if err != nil {
log.Fatal(err)
}
}
func loadScene(sceneId int) {
if eng != nil {
eng.Release()
}
eng = glsprite.Engine(images)
scene = &sprite.Node{}
eng.Register(scene)
eng.SetTransform(scene, f32.Affine{
{1, 0, 0},
{0, 1, 0},
})
switch sceneId {
case 0:
// load Gopher
Title.Move(screenSizeX/2, screenSizeY/2)
Title.width = screenSizeX
Title.height = screenSizeY
Title.radian = 0
tex_title := loadTextures("title.png", image.Rect(0, 0, int(screenSizeX), int(screenSizeY)))
Title.node = newNode()
eng.SetSubTex(Title.node, tex_title)
Title.Apply()
case 1:
// load Gopher
Gopher.Move(screenSizeX/2, screenSizeY/2)
Gopher.width = spriteSizeX
Gopher.height = spriteSizeY
Gopher.radian = 0
tex_gopher := loadTextures("waza-gophers.jpeg", image.Rect(152, 10, 152+int(Gopher.width), 10+int(Gopher.height)))
Gopher.node = newNode()
eng.SetSubTex(Gopher.node, tex_gopher)
Gopher.Apply()
// load Ball
Ball.Move(screenSizeX/3, screenSizeY/3)
Ball.width = 48
Ball.height = 48
Ball.radian = 0
tex_ball := loadTextures("ball.png", image.Rect(0, 0, int(Ball.width), int(Ball.height)))
Ball.node = newNode()
eng.SetSubTex(Ball.node, tex_ball)
Ball.Apply()
}
}
func NewEngine(screenWidth, screenHeight int) *Engine {
e := new(Engine)
e.screenWidth = screenWidth
e.screenHeight = screenHeight
e.startTime = time.Now()
e.eng = glsprite.Engine()
e.scene = &s.Node{}
e.eng.Register(e.scene)
e.eng.SetTransform(e.scene, f32.Affine{
{1, 0, 0},
{0, 1, 0},
})
e.arranger = new(arrangerFunc)
e.arranger.eng = e
e.sprites = make(map[*s.Node]*Sprite)
return e
}
"github.com/acsellers/ofs/game"
"golang.org/x/mobile/app"
"golang.org/x/mobile/asset"
"golang.org/x/mobile/event/paint"
"golang.org/x/mobile/event/size"
"golang.org/x/mobile/exp/app/debug"
"golang.org/x/mobile/exp/f32"
"golang.org/x/mobile/exp/sprite"
"golang.org/x/mobile/exp/sprite/clock"
"golang.org/x/mobile/exp/sprite/glsprite"
"golang.org/x/mobile/gl"
)
var (
v game.Vault
eng = glsprite.Engine()
scene *sprite.Node
start = time.Now()
dbg = flag.Bool("debug", false, "Turn on debug mode")
)
func main() {
flag.Parse()
v = game.NewVault()
v.PlaceRoom(9, 0, 1)
v.PlaceRoom(9, 1, 1)
v.PlaceRoom(10, 1, 2)
// setup transparency for sprites
gl.Disable(gl.DEPTH_TEST)
// 開始時点で呼ばれる関数なので、Sprite Engineを初期化する
func onStart(glctx gl.Context) {
images = glutil.NewImages(glctx) //OpenGLのContextからImageオブジェクトを生成
eng = glsprite.Engine(images) // Engineオブジェクトを生成する
game = NewGame()
scene = game.Scene(eng)
}
func onStart(glctx gl.Context) {
images = glutil.NewImages(glctx)
fps = debug.NewFPS(images)
eng = glsprite.Engine(images)
loadScene()
}
func onStart(glctx gl.Context) {
images = glutil.NewImages(glctx)
eng = glsprite.Engine(images)
game = NewGame()
scene = game.Scene(eng)
}
