public static Offset<LoginRequest> CreateLoginRequest(FlatBufferBuilder builder,
StringOffset name = default(StringOffset))
{
builder.StartObject(1);
LoginRequest.AddName(builder, name);
return LoginRequest.EndLoginRequest(builder);
}
public static Offset<uvSwapItemMesh> CreateuvSwapItemMesh(FlatBufferBuilder builder,
StringOffset name = default(StringOffset),
VectorOffset items = default(VectorOffset))
{
builder.StartObject(2);
uvSwapItemMesh.AddItems(builder, items);
uvSwapItemMesh.AddName(builder, name);
return uvSwapItemMesh.EnduvSwapItemMesh(builder);
}
public static Offset<TypeAmount> CreateTypeAmount(FlatBufferBuilder builder,
StringOffset type = default(StringOffset),
int amount = 0)
{
builder.StartObject(2);
TypeAmount.AddAmount(builder, amount);
TypeAmount.AddType(builder, type);
return TypeAmount.EndTypeAmount(builder);
}
public static Offset<anchorPointData> CreateanchorPointData(FlatBufferBuilder builder,
VectorOffset point = default(VectorOffset),
StringOffset anim_clip_name = default(StringOffset))
{
builder.StartObject(2);
anchorPointData.AddAnimClipName(builder, anim_clip_name);
anchorPointData.AddPoint(builder, point);
return anchorPointData.EndanchorPointData(builder);
}
public static Offset<animationMeshOpacity> CreateanimationMeshOpacity(FlatBufferBuilder builder,
StringOffset name = default(StringOffset),
float opacity = 0)
{
builder.StartObject(2);
animationMeshOpacity.AddOpacity(builder, opacity);
animationMeshOpacity.AddName(builder, name);
return animationMeshOpacity.EndanimationMeshOpacity(builder);
}
public static Offset<Stat> CreateStat(FlatBufferBuilder builder,
StringOffset idOffset = default(StringOffset),
long val = 0,
ushort count = 0) {
builder.StartObject(3);
Stat.AddVal(builder, val);
Stat.AddId(builder, idOffset);
Stat.AddCount(builder, count);
return Stat.EndStat(builder);
}
public static Offset<Defence> CreateDefence(FlatBufferBuilder builder,
StringOffset type = default(StringOffset),
sbyte level = 0,
int hp = 0)
{
builder.StartObject(3);
Defence.AddHp(builder, hp);
Defence.AddType(builder, type);
Defence.AddLevel(builder, level);
return Defence.EndDefence(builder);
}
public static Offset<animationBone> CreateanimationBone(FlatBufferBuilder builder,
StringOffset name = default(StringOffset),
VectorOffset start_pt = default(VectorOffset),
VectorOffset end_pt = default(VectorOffset))
{
builder.StartObject(3);
animationBone.AddEndPt(builder, end_pt);
animationBone.AddStartPt(builder, start_pt);
animationBone.AddName(builder, name);
return animationBone.EndanimationBone(builder);
}
public static Offset<Corretor> CreateCorretor(FlatBufferBuilder builder,
StringOffset nome = default(StringOffset),
StringOffset telefone = default(StringOffset),
StringOffset creci = default(StringOffset))
{
builder.StartObject(3);
Corretor.AddCreci(builder, creci);
Corretor.AddTelefone(builder, telefone);
Corretor.AddNome(builder, nome);
return Corretor.EndCorretor(builder);
}
public static Offset<CurrentQuest> CreateCurrentQuest(FlatBufferBuilder builder,
StringOffset name = default(StringOffset),
int taskAmountToComplete = 0,
int taskAmountDone = 0,
bool done = false)
{
builder.StartObject(4);
CurrentQuest.AddTaskAmountDone(builder, taskAmountDone);
CurrentQuest.AddTaskAmountToComplete(builder, taskAmountToComplete);
CurrentQuest.AddName(builder, name);
CurrentQuest.AddDone(builder, done);
return CurrentQuest.EndCurrentQuest(builder);
}
public static Offset<Island> CreateIsland(FlatBufferBuilder builder,
StringOffset name = default(StringOffset),
StringOffset owner = default(StringOffset),
sbyte level = 0,
Offset<TimeInterval> production = default(Offset<TimeInterval>),
VectorOffset defences = default(VectorOffset))
{
builder.StartObject(5);
Island.AddDefences(builder, defences);
Island.AddProduction(builder, production);
Island.AddOwner(builder, owner);
Island.AddName(builder, name);
Island.AddLevel(builder, level);
return Island.EndIsland(builder);
}
public static Offset<animationClip> CreateanimationClip(FlatBufferBuilder builder,
StringOffset name = default(StringOffset),
Offset<animationBonesList> bones = default(Offset<animationBonesList>),
Offset<animationMeshList> meshes = default(Offset<animationMeshList>),
Offset<animationUVSwapList> uvSwaps = default(Offset<animationUVSwapList>),
Offset<animationMeshOpacityList> meshOpacities = default(Offset<animationMeshOpacityList>))
{
builder.StartObject(5);
animationClip.AddMeshOpacities(builder, meshOpacities);
animationClip.AddUvSwaps(builder, uvSwaps);
animationClip.AddMeshes(builder, meshes);
animationClip.AddBones(builder, bones);
animationClip.AddName(builder, name);
return animationClip.EndanimationClip(builder);
}
VectorOffset createCompletedQuests(FlatBufferBuilder fbb)
{
if(!metaPool.hasQuestsCompleted){
return default(VectorOffset);
}
int count = metaPool.questsCompleted.ids.Count;
StringOffset[] questArray = new StringOffset[count];
int index = 0;
foreach (var quests in metaPool.questsCompleted.ids) {
questArray[index] = fbb.CreateString(quests);
index++;
}
return GameData.CreateCompletedQuestsVector(fbb, questArray);
}
public static Offset<animationUVSwap> CreateanimationUVSwap(FlatBufferBuilder builder,
StringOffset name = default(StringOffset),
VectorOffset local_offset = default(VectorOffset),
VectorOffset global_offset = default(VectorOffset),
VectorOffset scale = default(VectorOffset),
bool enabled = false)
{
builder.StartObject(5);
animationUVSwap.AddScale(builder, scale);
animationUVSwap.AddGlobalOffset(builder, global_offset);
animationUVSwap.AddLocalOffset(builder, local_offset);
animationUVSwap.AddName(builder, name);
animationUVSwap.AddEnabled(builder, enabled);
return animationUVSwap.EndanimationUVSwap(builder);
}
public static Offset<Building> CreateBuilding(FlatBufferBuilder builder,
StringOffset type = default(StringOffset),
sbyte level = 0,
Offset<Position> position = default(Offset<Position>),
bool paused = false,
Offset<TimeInterval> production = default(Offset<TimeInterval>),
VectorOffset storage = default(VectorOffset))
{
builder.StartObject(6);
Building.AddStorage(builder, storage);
Building.AddProduction(builder, production);
Building.AddPosition(builder, position);
Building.AddType(builder, type);
Building.AddPaused(builder, paused);
Building.AddLevel(builder, level);
return Building.EndBuilding(builder);
}
public static Offset<Ship> CreateShip(FlatBufferBuilder builder,
StringOffset type = default(StringOffset),
float status = 0,
sbyte order = 0,
sbyte level = 0,
VectorOffset cargo = default(VectorOffset),
VectorOffset armyCargo = default(VectorOffset))
{
builder.StartObject(6);
Ship.AddArmyCargo(builder, armyCargo);
Ship.AddCargo(builder, cargo);
Ship.AddStatus(builder, status);
Ship.AddType(builder, type);
Ship.AddLevel(builder, level);
Ship.AddOrder(builder, order);
return Ship.EndShip(builder);
}
public static Offset<animationMesh> CreateanimationMesh(FlatBufferBuilder builder,
StringOffset name = default(StringOffset),
bool use_dq = false,
bool use_local_displacements = false,
bool use_post_displacements = false,
VectorOffset local_displacements = default(VectorOffset),
VectorOffset post_displacements = default(VectorOffset))
{
builder.StartObject(6);
animationMesh.AddPostDisplacements(builder, post_displacements);
animationMesh.AddLocalDisplacements(builder, local_displacements);
animationMesh.AddName(builder, name);
animationMesh.AddUsePostDisplacements(builder, use_post_displacements);
animationMesh.AddUseLocalDisplacements(builder, use_local_displacements);
animationMesh.AddUseDq(builder, use_dq);
return animationMesh.EndanimationMesh(builder);
}
public static Offset<meshRegion> CreatemeshRegion(FlatBufferBuilder builder,
StringOffset name = default(StringOffset),
int start_pt_index = 0,
int end_pt_index = 0,
int start_index = 0,
int end_index = 0,
int id = 0,
VectorOffset weights = default(VectorOffset))
{
builder.StartObject(7);
meshRegion.AddWeights(builder, weights);
meshRegion.AddId(builder, id);
meshRegion.AddEndIndex(builder, end_index);
meshRegion.AddStartIndex(builder, start_index);
meshRegion.AddEndPtIndex(builder, end_pt_index);
meshRegion.AddStartPtIndex(builder, start_pt_index);
meshRegion.AddName(builder, name);
return meshRegion.EndmeshRegion(builder);
}
public static Offset<Imobiliaria> CreateImobiliaria(FlatBufferBuilder builder,
StringOffset nome = default(StringOffset),
StringOffset endereco = default(StringOffset),
ushort numero = 0,
StringOffset bairro = default(StringOffset),
StringOffset cidade = default(StringOffset),
Estado estado = (Estado)0,
StringOffset telefone = default(StringOffset))
{
builder.StartObject(7);
Imobiliaria.AddTelefone(builder, telefone);
Imobiliaria.AddCidade(builder, cidade);
Imobiliaria.AddBairro(builder, bairro);
Imobiliaria.AddEndereco(builder, endereco);
Imobiliaria.AddNome(builder, nome);
Imobiliaria.AddNumero(builder, numero);
Imobiliaria.AddEstado(builder, estado);
return Imobiliaria.EndImobiliaria(builder);
}
public static void AddStrValue(FlatBufferBuilder builder, StringOffset strValueOffset)
{
builder.AddOffset(2, strValueOffset.Value, 0);
}
public static void AddActorName(FlatBufferBuilder builder, StringOffset actorNameOffset)
{
builder.AddOffset(0, actorNameOffset.Value, 0);
}
public static void AddDisplayableName(FlatBufferBuilder builder, StringOffset displayableNameOffset)
{
builder.AddOffset(0, displayableNameOffset.Value, 0);
}
public static void AddPlayerName(FlatBufferBuilder builder, StringOffset playerNameOffset)
{
builder.AddOffset(0, playerNameOffset.Value, 0);
}
public static void AddPath(FlatBufferBuilder builder, StringOffset PathOffset)
{
builder.AddOffset(1, PathOffset.Value, 0);
}
public static void AddConfigPath(FlatBufferBuilder builder, StringOffset ConfigPathOffset)
{
builder.AddOffset(2, ConfigPathOffset.Value, 0);
}
public static void AddBairro(FlatBufferBuilder builder, StringOffset bairroOffset)
{
builder.AddOffset(3, bairroOffset.Value, 0);
}
public static void AddRoleId(FlatBufferBuilder builder, StringOffset roleIdOffset)
{
builder.AddOffset(0, roleIdOffset.Value, 0);
}
public static void AddShow(FlatBufferBuilder builder, StringOffset ShowOffset)
{
builder.AddOffset(4, ShowOffset.Value, 0);
}
public static void AddExpressName(FlatBufferBuilder builder, StringOffset ExpressNameOffset)
{
builder.AddOffset(3, ExpressNameOffset.Value, 0);
}
public static void AddSpriteName(FlatBufferBuilder builder, StringOffset SpriteNameOffset)
{
builder.AddOffset(2, SpriteNameOffset.Value, 0);
}
public static void AddLastName(FlatBufferBuilder builder, StringOffset lastNameOffset)
{
builder.AddOffset(2, lastNameOffset.Value, 0);
}
public static void AddComment(FlatBufferBuilder builder, StringOffset commentOffset)
{
builder.AddOffset(3, commentOffset.Value, 0);
}
public static Offset <Dragapult.Models.PokemonCatalogEntry> CreatePokemonCatalogEntry(FlatBufferBuilder builder,
Offset <Dragapult.Models.PokemonCatalogEntryDetails> DetailsOffset = default(Offset <Dragapult.Models.PokemonCatalogEntryDetails>),
StringOffset ModelPathOffset = default(StringOffset),
StringOffset ConfigPathOffset = default(StringOffset),
StringOffset PackagePathOffset = default(StringOffset),
VectorOffset AnimationConfigurationsOffset = default(VectorOffset))
{
builder.StartTable(5);
PokemonCatalogEntry.AddAnimationConfigurations(builder, AnimationConfigurationsOffset);
PokemonCatalogEntry.AddPackagePath(builder, PackagePathOffset);
PokemonCatalogEntry.AddConfigPath(builder, ConfigPathOffset);
PokemonCatalogEntry.AddModelPath(builder, ModelPathOffset);
PokemonCatalogEntry.AddDetails(builder, DetailsOffset);
return(PokemonCatalogEntry.EndPokemonCatalogEntry(builder));
}
public static void AddEndereco(FlatBufferBuilder builder, StringOffset enderecoOffset)
{
builder.AddOffset(1, enderecoOffset.Value, 0);
}
public static Offset <Dragapult.Models.PokemonCatalogEntryAnimationConfig> CreatePokemonCatalogEntryAnimationConfig(FlatBufferBuilder builder,
StringOffset NameOffset = default(StringOffset),
StringOffset PathOffset = default(StringOffset))
{
builder.StartTable(2);
PokemonCatalogEntryAnimationConfig.AddPath(builder, PathOffset);
PokemonCatalogEntryAnimationConfig.AddName(builder, NameOffset);
return(PokemonCatalogEntryAnimationConfig.EndPokemonCatalogEntryAnimationConfig(builder));
}
public static void AddType(FlatBufferBuilder builder, StringOffset typeOffset)
{
builder.AddOffset(1, typeOffset.Value, 0);
}
public static void AddName(FlatBufferBuilder builder, StringOffset nameOffset)
{
builder.AddOffset(1, nameOffset.Value, 0);
}
public static void AddEnvironmentName(FlatBufferBuilder builder, StringOffset environmentNameOffset)
{
builder.AddOffset(0, environmentNameOffset.Value, 0);
}
public static Offset <Dragapult.Models.PokemonModelInfo> CreatePokemonModelInfo(FlatBufferBuilder builder,
StringOffset NameOffset = default(StringOffset))
{
builder.StartTable(1);
PokemonModelInfo.AddName(builder, NameOffset);
return(PokemonModelInfo.EndPokemonModelInfo(builder));
}
public static void AddId(FlatBufferBuilder builder, StringOffset idOffset)
{
builder.AddOffset(0, idOffset.Value, 0);
}
public static void AddEffectName(FlatBufferBuilder builder, StringOffset effectNameOffset)
{
builder.AddOffset(3, effectNameOffset.Value, 0);
}
public static void AddConfigurableName(FlatBufferBuilder builder, StringOffset configurableNameOffset)
{
builder.AddOffset(0, configurableNameOffset.Value, 0);
}
public static void AddCreci(FlatBufferBuilder builder, StringOffset creciOffset)
{
builder.AddOffset(2, creciOffset.Value, 0);
}
public static void AddId(FlatBufferBuilder builder, StringOffset idOffset)
{
builder.AddOffset(2, idOffset.Value, 0);
}
public static Offset<GameData> CreateGameData(FlatBufferBuilder builder,
Offset<Workers> workers = default(Offset<Workers>),
VectorOffset unitLevels = default(VectorOffset),
int trophies = 0,
VectorOffset technologies = default(VectorOffset),
VectorOffset ships = default(VectorOffset),
VectorOffset sectors = default(VectorOffset),
VectorOffset currentQuests = default(VectorOffset),
VectorOffset completedQuests = default(VectorOffset),
VectorOffset playerResources = default(VectorOffset),
StringOffset playerName = default(StringOffset),
long nextPirateAttack = 0,
VectorOffset leftOverResources = default(VectorOffset),
VectorOffset islands = default(VectorOffset),
sbyte fortressLevel = 0,
VectorOffset defences = default(VectorOffset),
VectorOffset buildings = default(VectorOffset))
{
builder.StartObject(16);
GameData.AddNextPirateAttack(builder, nextPirateAttack);
GameData.AddBuildings(builder, buildings);
GameData.AddDefences(builder, defences);
GameData.AddIslands(builder, islands);
GameData.AddLeftOverResources(builder, leftOverResources);
GameData.AddPlayerName(builder, playerName);
GameData.AddPlayerResources(builder, playerResources);
GameData.AddCompletedQuests(builder, completedQuests);
GameData.AddCurrentQuests(builder, currentQuests);
GameData.AddSectors(builder, sectors);
GameData.AddShips(builder, ships);
GameData.AddTechnologies(builder, technologies);
GameData.AddTrophies(builder, trophies);
GameData.AddUnitLevels(builder, unitLevels);
GameData.AddWorkers(builder, workers);
GameData.AddFortressLevel(builder, fortressLevel);
return GameData.EndGameData(builder);
}
public static void AddSerialisedMessage(FlatBufferBuilder builder, StringOffset serialisedMessageOffset)
{
builder.AddOffset(6, serialisedMessageOffset.Value, 0);
}
public static void AddMethod(FlatBufferBuilder builder, StringOffset methodOffset)
{
builder.AddOffset(1, methodOffset.Value, 0);
}
public static void AddPass(FlatBufferBuilder builder, StringOffset passOffset)
{
builder.AddOffset(3, passOffset.Value, 0);
}
public static void AddCidade(FlatBufferBuilder builder, StringOffset cidadeOffset)
{
builder.AddOffset(4, cidadeOffset.Value, 0);
}
public static void AddEntityId(FlatBufferBuilder builder, StringOffset entityIdOffset)
{
builder.AddOffset(0, entityIdOffset.Value, 0);
}
public static void AddTelefone(FlatBufferBuilder builder, StringOffset telefoneOffset)
{
builder.AddOffset(6, telefoneOffset.Value, 0);
}
public static void AddOutputOfOp(FlatBufferBuilder builder, StringOffset outputOfOpOffset)
{
builder.AddOffset(6, outputOfOpOffset.Value, 0);
}
public static void AddType(FlatBufferBuilder builder, StringOffset typeOffset)
{
builder.AddOffset(0, typeOffset.Value, 0);
}
public static void AddGradientVariable(FlatBufferBuilder builder, StringOffset gradientVariableOffset)
{
builder.AddOffset(10, gradientVariableOffset.Value, 0);
}
public static void AddName(FlatBufferBuilder builder, StringOffset nameOffset)
{
builder.AddOffset(0, nameOffset.Value, 0);
}
public static void AddUiLabelExtra(FlatBufferBuilder builder, StringOffset uiLabelExtraOffset)
{
builder.AddOffset(11, uiLabelExtraOffset.Value, 0);
}
public static void AddPlayerName(FlatBufferBuilder builder, StringOffset playerNameOffset)
{
builder.AddOffset(9, playerNameOffset.Value, 0);
}
public static void Add_id(FlatBufferBuilder builder, StringOffset IdOffset)
{
builder.AddOffset(0, IdOffset.Value, 0);
}
public static VectorOffset CreateTechnologiesVector(FlatBufferBuilder builder, StringOffset[] data)
{
builder.StartVector(4, data.Length, 4); for (int i = data.Length - 1; i >= 0; i--) builder.AddOffset(data[i].Value); return builder.EndVector();
}
public static void AddKey(FlatBufferBuilder builder, StringOffset keyOffset)
{
builder.AddOffset(0, keyOffset.Value, 0);
}
