/*

* Copyright 2015 Google Inc. All rights reserved.

*

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

// To run, use the `go_sample.sh` script.

package main

import (

sample "MyGame/Sample"

"fmt"

flatbuffers "github.com/google/flatbuffers/go"

"strconv"

)

// Example how to use Flatbuffers to create and read binary buffers.

func main() {

builder := flatbuffers.NewBuilder(0)

// Create some weapons for our Monster ("Sword" and "Axe").

weaponOne := builder.CreateString("Sword")

weaponTwo := builder.CreateString("Axe")

sample.WeaponStart(builder)

sample.WeaponAddName(builder, weaponOne)

sample.WeaponAddDamage(builder, 3)

sword := sample.WeaponEnd(builder)

sample.WeaponStart(builder)

sample.WeaponAddName(builder, weaponTwo)

sample.WeaponAddDamage(builder, 5)

axe := sample.WeaponEnd(builder)

// Serialize the FlatBuffer data.

name := builder.CreateString("Orc")

sample.MonsterStartInventoryVector(builder, 10)

// Note: Since we prepend the bytes, this loop iterates in reverse.

for i := 9; i >= 0; i-- {

builder.PrependByte(byte(i))

}

inv := builder.EndVector(10)

sample.MonsterStartWeaponsVector(builder, 2)

// Note: Since we prepend the weapons, prepend in reverse order.

builder.PrependUOffsetT(axe)

builder.PrependUOffsetT(sword)

weapons := builder.EndVector(2)

pos := sample.CreateVec3(builder, 1.0, 2.0, 3.0)

sample.MonsterStart(builder)

sample.MonsterAddPos(builder, pos)

sample.MonsterAddHp(builder, 300)

sample.MonsterAddName(builder, name)

sample.MonsterAddInventory(builder, inv)

sample.MonsterAddColor(builder, sample.ColorRed)

sample.MonsterAddWeapons(builder, weapons)

sample.MonsterAddEquippedType(builder, sample.EquipmentWeapon)

sample.MonsterAddEquipped(builder, axe)

orc := sample.MonsterEnd(builder)

builder.Finish(orc)

// We now have a FlatBuffer that we could store on disk or send over a network.

// ...Saving to file or sending over a network code goes here...

// Instead, we are going to access this buffer right away (as if we just received it).

buf := builder.FinishedBytes()

// Note: We use `0` for the offset here, since we got the data using the

// `builder.FinishedBytes()` method. This simulates the data you would store/receive in your

// FlatBuffer. If you wanted to read from the `builder.Bytes` directly, you would need to

// pass in the offset of `builder.Head()`, as the builder actually constructs the buffer

// backwards.

monster := sample.GetRootAsMonster(buf, 0)

// Note: We did not set the `mana` field explicitly, so we get the

// default value.

assert(monster.Mana() == 150, "`monster.Mana()`", strconv.Itoa(int(monster.Mana())), "150")

assert(monster.Hp() == 300, "`monster.Hp()`", strconv.Itoa(int(monster.Hp())), "300")

assert(string(monster.Name()) == "Orc", "`string(monster.Name())`", string(monster.Name()),

"\"Orc\"")

assert(monster.Color() == sample.ColorRed, "`monster.Color()`",

strconv.Itoa(int(monster.Color())), strconv.Itoa(int(sample.ColorRed)))

// Note: Whenever you access a new object, like in `Pos()`, a new temporary accessor object

// gets created. If your code is very performance sensitive, you can pass in a pointer to an

// existing `Vec3` instead of `nil`. This allows you to reuse it across many calls to reduce

// the amount of object allocation/garbage collection.

assert(monster.Pos(nil).X() == 1.0, "`monster.Pos(nil).X()`",

strconv.FormatFloat(float64(monster.Pos(nil).X()), 'f', 1, 32), "1.0")

assert(monster.Pos(nil).Y() == 2.0, "`monster.Pos(nil).Y()`",

strconv.FormatFloat(float64(monster.Pos(nil).Y()), 'f', 1, 32), "2.0")

assert(monster.Pos(nil).Z() == 3.0, "`monster.Pos(nil).Z()`",

strconv.FormatFloat(float64(monster.Pos(nil).Z()), 'f', 1, 32), "3.0")

// For vectors, like `Inventory`, they have a method suffixed with 'Length' that can be used

// to query the length of the vector. You can index the vector by passing an index value

// into the accessor.

for i := 0; i < monster.InventoryLength(); i++ {

assert(monster.Inventory(i) == byte(i), "`monster.Inventory(i)`",

strconv.Itoa(int(monster.Inventory(i))), strconv.Itoa(int(byte(i))))

}

expectedWeaponNames := []string{"Sword", "Axe"}

expectedWeaponDamages := []int{3, 5}

weapon := new(sample.Weapon) // We need a `sample.Weapon` to pass into `monster.Weapons()`

// to capture the output of that function.

for i := 0; i < monster.WeaponsLength(); i++ {

if monster.Weapons(weapon, i) {

assert(string(weapon.Name()) == expectedWeaponNames[i], "`weapon.Name()`",

string(weapon.Name()), expectedWeaponNames[i])

assert(int(weapon.Damage()) == expectedWeaponDamages[i],

"`weapon.Damage()`", strconv.Itoa(int(weapon.Damage())),

strconv.Itoa(expectedWeaponDamages[i]))

}

}

// For FlatBuffer `union`s, you can get the type of the union, as well as the union

// data itself.

assert(monster.EquippedType() == sample.EquipmentWeapon, "`monster.EquippedType()`",

strconv.Itoa(int(monster.EquippedType())), strconv.Itoa(int(sample.EquipmentWeapon)))

unionTable := new(flatbuffers.Table)

if monster.Equipped(unionTable) {

// An example of how you can appropriately convert the table depending on the

// FlatBuffer `union` type. You could add `else if` and `else` clauses to handle

// other FlatBuffer `union` types for this field. (Similarly, this could be

// done in a switch statement.)

if monster.EquippedType() == sample.EquipmentWeapon {

unionWeapon := new(sample.Weapon)

unionWeapon.Init(unionTable.Bytes, unionTable.Pos)

assert(string(unionWeapon.Name()) == "Axe", "`unionWeapon.Name()`",

string(unionWeapon.Name()), "Axe")

assert(int(unionWeapon.Damage()) == 5, "`unionWeapon.Damage()`",

strconv.Itoa(int(unionWeapon.Damage())), strconv.Itoa(5))

}

}

fmt.Printf("The FlatBuffer was successfully created and verified!\n")

}

// A helper function to print out if an assertion failed.

func assert(assertPassed bool, codeExecuted string, actualValue string, expectedValue string) {

if assertPassed == false {

panic("Assert failed! " + codeExecuted + " (" + actualValue +

") was not equal to " + expectedValue + ".")

}

}