public void UpdateTailParts() { GameObject Tail = ParentObject; GameObject Owner = Tail.Equipped; Mutations PMu = Owner.GetPart <Mutations>(); ThickTail TailMutation = base.ParentObject.Equipped.GetPart <Mutations>().GetMutation("ThickTail") as ThickTail; int ChimeraBoost = ((Owner.StatMod("Strength") + Owner.StatMod("Toughness") + Owner.StatMod("Agility")) / 3); if (Owner == null) { return; } if (PMu.HasMutation("Chimera")) { SynergyConstruct Construct; bool SynergizedChi = SynergyEffects.TryGetValue("Chimera", out Construct); if (SynergizedChi && Construct.IsActive == false) { Construct.Effect.Invoke(ParentObject); Construct.IsActive = true; } } foreach (BaseMutation Mut in PMu.MutationList) { SynergyConstruct Construct; bool Synergized = SynergyEffects.TryGetValue(Mut.Name, out Construct); if (Synergized && Construct.IsActive == false) { Construct.Effect.Invoke(ParentObject); Construct.IsActive = true; } } }
public void DeleteFromRow() { var mutation = Mutations.DeleteFromRow(); Assert.NotNull(mutation.DeleteFromRow); Assert.True(mutation.IsIdempotent()); }
public async Task CheckAndMutateRow_Validate_RowKey() { var client = new TestBigtableClient(); var tableName = new TableName("project", "instance", "table"); await CheckAndMutateRow_ValidateArguments <ArgumentException>( tableName, "", RowFilters.PassAllFilter(), new[] { Mutations.DeleteFromRow() }, new[] { Mutations.DeleteFromRow() }); await CheckAndMutateRow_ValidateArguments <ArgumentException>( tableName, new byte[0], RowFilters.PassAllFilter(), new[] { Mutations.DeleteFromRow() }, new[] { Mutations.DeleteFromRow() }); await CheckAndMutateRow_ValidateArguments <ArgumentException>( tableName, ByteString.Empty, RowFilters.PassAllFilter(), new[] { Mutations.DeleteFromRow() }, new[] { Mutations.DeleteFromRow() }); await CheckAndMutateRow_ValidateArguments <ArgumentException>( tableName,
public async Task CheckAndMutateRow_Validate_Mutations() { var tableName = new TableName("project", "instance", "table"); await CheckAndMutateRow_ValidateArguments <ArgumentException>( tableName, "abc", RowFilters.PassAllFilter(), null, null); await CheckAndMutateRow_ValidateArguments <ArgumentException>( tableName, "abc", RowFilters.PassAllFilter(), new Mutation[0], new Mutation[0]); await CheckAndMutateRow_ValidateArguments <ArgumentException>( tableName, "abc", RowFilters.PassAllFilter(), new Mutation[] { null }, new[] { Mutations.DeleteFromRow() }, callTrueMutationsOnlyOverload : false); await CheckAndMutateRow_ValidateArguments <ArgumentException>( tableName, "abc", RowFilters.PassAllFilter(), new[] { Mutations.DeleteFromRow() }, new Mutation[] { null }, callTrueMutationsOnlyOverload : false); }
/// <summary> /// Sends all changes registered on Document sets to Sanity as a transactional set of mutations. /// </summary> /// <param name="returnIds"></param> /// <param name="returnDocuments"></param> /// <param name="visibility"></param> /// <returns></returns> public async Task <SanityMutationResponse> CommitAsync(bool returnIds = false, bool returnDocuments = false, SanityMutationVisibility visibility = SanityMutationVisibility.Sync, CancellationToken cancellationToken = default) { var result = await Client.CommitMutationsAsync(Mutations.Build(Client.SerializerSettings), returnIds, returnDocuments, visibility, cancellationToken).ConfigureAwait(false); Mutations.Clear(); return(result); }
public void domutate() { if (ParentObject.IsPlayer() || ParentObject.IsMemberOfFaction("Templar")) { return; } int roll = Stat.Random(1, 100); Log("Titroll:" + roll.ToString() + "/" + Chance.ToString()); if (roll <= Chance) { Mutations mutations = ParentObject.GetPart("Mutations") as Mutations; if (mutations == null) { Log("Can mutate, no mutations part"); return; } if (!MutationFactory.MutationsByName.ContainsKey(Mutation)) { Log("Mutation " + Mutation + " isn't recognised"); } mutations.AddMutation(MutationFactory.MutationsByName[Mutation].CreateInstance(), Level); Log("mutated"); } }
public override bool FireEvent(Event E) { if (E.ID == "EndTurnEngulfing") { if (descriptionSet == false) { IPart.ThePlayer.GetPart <Description>().Short = "I'm not a bad slime"; descriptionSet = true; } GameObject parameter = E.GetParameter <GameObject>("Object"); if (parameter != null) { Damage damage = new Damage(Stat.Random(IPart.ThePlayer.Statistics["Toughness"].BaseValue / 2, IPart.ThePlayer.Statistics["Toughness"].BaseValue)); Event E1 = Event.New("TakeDamage", 0, 0, 0); E1.AddParameter("Damage", (object)damage); E1.AddParameter("Owner", (object)this.ParentObject); E1.AddParameter("Attacker", (object)this.ParentObject); E1.AddParameter("Message", this.DamageMessage); parameter.FireEvent(E1); if (parameter.hitpoints <= 0) { if (DifficultyEvaluation.GetDifficultyDescription(parameter) == "&wAverage") { this.statGains(1); } else if (DifficultyEvaluation.GetDifficultyDescription(parameter) == "&WTough") { this.statGains(2); } else if (DifficultyEvaluation.GetDifficultyDescription(parameter) == "&rVery Tough") { this.statGains(4); } else if (DifficultyEvaluation.GetDifficultyDescription(parameter) == "&RImpossible") { this.statGains(8); } Mutations targetMutations = parameter.GetPart <Mutations>(); Mutations playerMutations = IPart.ThePlayer.GetPart <Mutations>(); if (targetMutations != null) { foreach (BaseMutation mutation in targetMutations.MutationList) { if (!playerMutations.HasMutation(mutation) && !excludedMutations.Contains(mutation.Name) && mutation.CompatibleWith(IPart.ThePlayer)) { playerMutations.AddMutation(mutation, 1); } } } Stomach part = IPart.ThePlayer.GetPart <Stomach>(); IPart.ThePlayer.RemoveEffect("Famished", false); part.HungerLevel = 0; part.CookCount = 0; part.CookingCounter = 0; part.Water = 30000; } } } return(true); }
public override bool HandleEvent(GetDisplayNameEvent E) { try { if (!NeedsSynergyPrefix) { return(true); } GameObject Tail = ParentObject; GameObject Owner = Tail.Equipped; Mutations HasSynergyMutation = Owner.GetPart <Mutations>(); int Synergies = SynergyMutations.Count(HasSynergyMutation.HasMutation); if (Synergies >= 3) { return(true); } foreach (var kv in SynergyEffects) { if (HasSynergyMutation.HasMutation(kv.Key)) { E.AddBase(kv.Value.Prefix, DescriptionBuilder.ORDER_ADJUST_EARLY); } } } catch { } return(base.HandleEvent(E)); }
private static void ApplyMutations(CharacterTemplate buildTemplate, List <MLNode> mutationNodes) { if (!buildTemplate.genotypeEntry.IsMutant) { return; } Mutations part = buildTemplate.PlayerBody.GetPart <Mutations>(); foreach (MLNode node in mutationNodes) { if (node.Entry != null && node.Selected > 0) { if (node.Entry.Mutation != null) { BaseMutation baseMutation = node.Entry.CreateInstance(); baseMutation.SetVariant(node.Variant); part.AddMutation(baseMutation, node.Selected); } else if (node.Entry.DisplayName == "Chimera") { buildTemplate.MutationLevel = "Chimera"; } else if (node.Entry.DisplayName == "Esper") { buildTemplate.MutationLevel = "Esper"; } } } }
/// <summary> /// Add Test Data into Given Google Cloud Bigtable /// </summary> public void InsertTestDataToTable() { try { if (!IsTableExists()) { throw new Exception("No Such Table Found"); } var bigtableClient = BigtableClient.Create(); List <Mutation> Cols = new List <Mutation>(); TableName _table = new TableName(ProjectId, InstanceId, TableName); var request = new MutateRowsRequest { TableNameAsTableName = _table, }; request.Entries.Add(Mutations.CreateEntry(Guid.NewGuid().ToString(), Mutations.SetCell(ColumnFamily, "TestColumnName", "Test Column Value"))); bigtableClient.MutateRows(request); } catch (RpcException ex) { throw ex; } catch (Exception ex) { throw ex; } }
public async Task RetryBeforeTotalExpiration() { var request = new MutateRowsRequest { Entries = { Mutations.CreateEntry("a", Mutations.DeleteFromRow()), Mutations.CreateEntry("b", Mutations.DeleteFromRow()), Mutations.CreateEntry("c", Mutations.DeleteFromRow()) } }; var client = Utilities.CreateMutateRowsMockClient( request, entriesForInitialStream: new[] { Utilities.CreateMutateRowsResponseEntry(0, Code.Ok), Utilities.CreateMutateRowsResponseEntry(1, Code.DeadlineExceeded), Utilities.CreateMutateRowsResponseEntry(2, Code.Ok) }, entriesForRetryStreams: new[] { null, // A null entry will throw an Unavailable RpcException // 2nd retry response entries new[] { Utilities.CreateMutateRowsResponseEntry(0, Code.Ok) } }); await client.MutateRowsAsync(request); }
public async Task RetryAfterTotalExpiration() { var settings = new BigtableServiceApiSettings(); // Don't allow for any time to retry. settings.MutateRowsSettings = CallSettings.FromExpiration(Expiration.FromTimeout(TimeSpan.Zero)); var request = new MutateRowsRequest { Entries = { Mutations.CreateEntry("a", Mutations.DeleteFromRow()), Mutations.CreateEntry("b", Mutations.DeleteFromRow()), Mutations.CreateEntry("c", Mutations.DeleteFromRow()) } }; var client = Utilities.CreateMutateRowsMockClient( request, entriesForInitialStream: new[] { Utilities.CreateMutateRowsResponseEntry(0, Code.Ok), Utilities.CreateMutateRowsResponseEntry(1, Code.DeadlineExceeded), Utilities.CreateMutateRowsResponseEntry(2, Code.Ok) }, entriesForRetryStreams: new[] { // 1st retry response entries new[] { Utilities.CreateMutateRowsResponseEntry(0, Code.Ok) } }, settings: settings); var exception = await Assert.ThrowsAsync <RpcException>(() => client.MutateRowsAsync(request)); Assert.Equal(StatusCode.DeadlineExceeded, exception.StatusCode); }
public void DeleteFromFamily(string familyName) { var mutation = Mutations.DeleteFromFamily(familyName); Assert.NotNull(mutation.DeleteFromFamily); Assert.Equal(familyName, mutation.DeleteFromFamily.FamilyName); }
public async Task <BigtableByteString> InsertRowAsync( TableName tableName, string familyName = null, BigtableByteString?qualifierName = null, BigtableByteString?value = null, BigtableVersion?version = null) { BigtableByteString rowKey = Guid.NewGuid().ToString(); familyName = familyName ?? DefaultColumnFamily; qualifierName = qualifierName ?? DefaultColumnQualifier; value = value ?? DefaultValue; await TableClient.MutateRowAsync( tableName, rowKey, Mutations.SetCell( familyName, qualifierName.Value, value.Value, version)); await BigtableAssert.HasSingleValueAsync( TableClient, tableName, rowKey, familyName, qualifierName.Value, value.Value, version); return(rowKey); }
protected override async Task DeleteAsync(string persistenceId, SnapshotSelectionCriteria criteria) { var filter = RowFilters.Chain ( RowFilters.ColumnQualifierExact(SnapshotMetaDataColumnQualifier), // this filter ensures that we only download snapshot metadata RowFilters.TimestampRange( ToUtc(criteria.MinTimestamp), ToUtc(criteria.MaxTimeStamp)?.AddMilliseconds(1) // add a milliseconds since the upper bound is exclusive ), RowFilters.CellsPerColumnLimit(1) ); var readRowsRequest = new ReadRowsRequest { TableNameAsTableName = _tableName, Filter = filter, Rows = GetRowSet(persistenceId, criteria.MinSequenceNr, criteria.MaxSequenceNr) }; var deleteMutations = await _bigtableClient .ReadRows(readRowsRequest) .Select(SnapshotMetadataFromBigtableRow) .Where(metadata => SatisfiesTimestampCriteria(criteria, metadata)) .Select(metadata => Mutations.CreateEntry(GetRowKey(persistenceId, metadata.SequenceNr), Mutations.DeleteFromRow())) .ToList() .ConfigureAwait(false); if (deleteMutations.Count > 0) { await _bigtableClient.MutateRowsAsync(_tableName, deleteMutations).ConfigureAwait(false); } }
public async Task InsertRowsAsync( TableName tableName, IEnumerable <BigtableByteString> rowKeys, string familyName = null, BigtableByteString?qualifierName = null, BigtableByteString?valuePrefix = null, BigtableVersion?version = null) { BigtableByteString rowKey = Guid.NewGuid().ToString(); familyName = familyName ?? DefaultColumnFamily; qualifierName = qualifierName ?? "row_index"; valuePrefix = valuePrefix ?? ""; int counter = 0; var response = await TableClient.MutateRowsAsync( tableName, rowKeys.Select(k => Mutations.CreateEntry( k.Value, Mutations.SetCell( familyName, qualifierName.Value, valuePrefix.Value.Value.Concat( new BigtableByteString(counter++).Value), version))).ToArray()); var entries = response.Entries.OrderBy(e => e.Index); Assert.True(entries.All(e => e.Status.Code == (int)Code.Ok)); }
public void IdempotentCheckOnMutateRowRequest() { var setCell = Mutations.SetCell("abc", "cq1", "value", new BigtableVersion(-1)); var deleteFromColumn = Mutations.DeleteFromColumn("abc", "def", new BigtableVersionRange(-1, -1)); var request = new MutateRowRequest { Mutations = { Mutations.DeleteFromRow(), setCell, deleteFromColumn, Mutations.DeleteFromFamily("abc") } }; Assert.True(request.IsIdempotent()); deleteFromColumn.DeleteFromColumn.TimeRange.StartTimestampMicros = -1; deleteFromColumn.DeleteFromColumn.TimeRange.EndTimestampMicros = -1; Assert.True(request.IsIdempotent()); setCell.SetCell.TimestampMicros = -1; Assert.False(request.IsIdempotent()); }
public override Void Execute() { if (Mutations.Count() == 0) { return(new Void()); } var mutationMap = new Dictionary <byte[], Dictionary <string, List <Mutation> > >(); foreach (var key in Mutations.GroupBy(x => x.Column.Family.Key)) { var keyMutations = new Dictionary <string, List <Mutation> >(); foreach (var columnFamily in key.GroupBy(x => x.Column.Family.FamilyName)) { var columnFamilyMutations = columnFamily .Where(m => m.Type == MutationType.Added || m.Type == MutationType.Changed) .Select(m => Helper.CreateInsertedOrChangedMutation(m)) .ToList(); var superColumnsNeedingDeleted = columnFamily .Where(m => m.Type == MutationType.Removed && m.Column.GetParent().SuperColumn != null); foreach (var superColumn in superColumnsNeedingDeleted.GroupBy(x => x.Column.GetParent().SuperColumn.ColumnName)) { columnFamilyMutations.AddRange(Helper.CreateDeletedSuperColumnMutation(superColumn)); } var columnsNeedingDeleted = columnFamily .Where(m => m.Type == MutationType.Removed && m.Column.GetParent().SuperColumn == null); if (columnsNeedingDeleted.Count() > 0) { columnFamilyMutations.AddRange(Helper.CreateDeletedColumnMutation(columnsNeedingDeleted)); } keyMutations.Add(columnFamily.Key, columnFamilyMutations); } mutationMap.Add(key.Key.TryToBigEndian(), keyMutations); } var client = Session.GetClient(); if (Atomic && client.describe_version() >= RpcApiVersion.Cassandra120) { client.atomic_batch_mutate( mutationMap, Session.WriteConsistency); } else { client.batch_mutate( mutationMap, Session.WriteConsistency); } return(new Void()); }
public void Mutations_Serialize_Should_Generate_When_Create_Added() { var mutations = new Mutations(); var result = mutations.AddCreate(new CreateTest()).Serialize(); Assert.NotNull(result); Assert.NotEmpty(result); }
public Polymorphism(Polymorphism currentPoly) { this.position = currentPoly.position; this.mutation = currentPoly.mutation; this.isBackMutation = currentPoly.isBackMutation; this.numberOfIns = currentPoly.numberOfIns; this.insertedPolys = currentPoly.insertedPolys; }
public void CreateEntry() { var entry = Mutations.CreateEntry("abc", Mutations.DeleteFromRow()); Assert.Equal("abc", entry.RowKey.ToStringUtf8()); Assert.Equal(1, entry.Mutations.Count); Assert.NotNull(entry.Mutations[0].DeleteFromRow); }
public BigtableClientFixture() { BigtableClient bigtableClient = BigtableClient.Create(); _bigtableTableAdminClient = BigtableTableAdminClient.Create(); Table table = new Table { Granularity = Table.Types.TimestampGranularity.Millis }; table.ColumnFamilies.Add("stats_summary", new ColumnFamily()); table.ColumnFamilies.Add("cell_plan", new ColumnFamily()); CreateTableRequest createTableRequest = new CreateTableRequest { ParentAsInstanceName = new InstanceName(projectId, instanceId), Table = table, TableId = tableId, }; _bigtableTableAdminClient.CreateTable(createTableRequest); TableName tableName = new TableName(projectId, instanceId, tableId); BigtableVersion timestamp = new BigtableVersion(new DateTime(2020, 1, 10, 14, 0, 0, DateTimeKind.Utc)); BigtableVersion timestamp_minus_hr = new BigtableVersion(new DateTime(2020, 1, 10, 13, 0, 0, DateTimeKind.Utc)); MutateRowsRequest.Types.Entry[] entries = { Mutations.CreateEntry(new BigtableByteString("phone#4c410523#20190501"), Mutations.SetCell("cell_plan", "data_plan_01gb", "false", timestamp), Mutations.SetCell("cell_plan", "data_plan_01gb", "true", timestamp_minus_hr), Mutations.SetCell("cell_plan", "data_plan_05gb", "true", timestamp), Mutations.SetCell("stats_summary", "connected_cell", "1", timestamp), Mutations.SetCell("stats_summary", "connected_wifi", "1", timestamp), Mutations.SetCell("stats_summary", "os_build", "PQ2A.190405.003", timestamp)), Mutations.CreateEntry(new BigtableByteString("phone#4c410523#20190502"), Mutations.SetCell("cell_plan", "data_plan_05gb", "true", timestamp), Mutations.SetCell("stats_summary", "connected_cell", "1", timestamp), Mutations.SetCell("stats_summary", "connected_wifi", "1", timestamp), Mutations.SetCell("stats_summary", "os_build", "PQ2A.190405.004", timestamp)), Mutations.CreateEntry(new BigtableByteString("phone#4c410523#20190505"), Mutations.SetCell("cell_plan", "data_plan_05gb", "true", timestamp), Mutations.SetCell("stats_summary", "connected_cell", "0", timestamp), Mutations.SetCell("stats_summary", "connected_wifi", "1", timestamp), Mutations.SetCell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)), Mutations.CreateEntry(new BigtableByteString("phone#5c10102#20190501"), Mutations.SetCell("cell_plan", "data_plan_10gb", "true", timestamp), Mutations.SetCell("stats_summary", "connected_cell", "1", timestamp), Mutations.SetCell("stats_summary", "connected_wifi", "1", timestamp), Mutations.SetCell("stats_summary", "os_build", "PQ2A.190401.002", timestamp)), Mutations.CreateEntry(new BigtableByteString("phone#5c10102#20190502"), Mutations.SetCell("cell_plan", "data_plan_10gb", "true", timestamp), Mutations.SetCell("stats_summary", "connected_cell", "1", timestamp), Mutations.SetCell("stats_summary", "connected_wifi", "0", timestamp), Mutations.SetCell("stats_summary", "os_build", "PQ2A.190406.000", timestamp)) }; bigtableClient.MutateRows(tableName, entries); }
// Use this for initialization void Start() { cell = gameObject.GetComponent<Stats> (); mute = gameObject.GetComponent<Mutations> (); show = false; posx = 50; posy = 15; GUI.color = Color.black; }
public void SetCell_NonIdempotent() { var mutation = Mutations.SetCell("abc", "cq1", "value", new BigtableVersion(-1)); Assert.True(mutation.IsIdempotent()); mutation.SetCell.TimestampMicros = -1; Assert.False(mutation.IsIdempotent()); }
public async Task CheckAndMutateRow_Validate_TableName() { await CheckAndMutateRow_ValidateArguments <ArgumentNullException>( null, "abc", RowFilters.PassAllFilter(), new[] { Mutations.DeleteFromRow() }, new[] { Mutations.DeleteFromRow() }); }
protected override async Task DeleteAsync(SnapshotMetadata metadata) { await _bigtableClient.MutateRowAsync( _tableName, GetRowKey(metadata.PersistenceId, metadata.SequenceNr), new List <Mutation> { Mutations.DeleteFromRow() }).ConfigureAwait(false); }
public void SetCell_String(string familyName) { var mutation = Mutations.SetCell(familyName, "cq1", "value", new BigtableVersion(3)); Assert.NotNull(mutation.SetCell); Assert.Equal(familyName, mutation.SetCell.FamilyName); Assert.Equal("cq1", mutation.SetCell.ColumnQualifier.ToStringUtf8()); Assert.Equal("value", mutation.SetCell.Value.ToStringUtf8()); Assert.Equal(3000, mutation.SetCell.TimestampMicros); }
public void DeleteFromColumn(string familyName) { var mutation = Mutations.DeleteFromColumn(familyName, "cq1", new BigtableVersionRange(1, 2)); Assert.NotNull(mutation.DeleteFromColumn); Assert.Equal(familyName, mutation.DeleteFromColumn.FamilyName); Assert.Equal("cq1", mutation.DeleteFromColumn.ColumnQualifier.ToStringUtf8()); Assert.Equal(1000, mutation.DeleteFromColumn.TimeRange.StartTimestampMicros); Assert.Equal(2000, mutation.DeleteFromColumn.TimeRange.EndTimestampMicros); }
public async Task CheckAndMutateRow_Validate_RowKey(BigtableByteString rowKey) { var tableName = new TableName("project", "instance", "table"); await CheckAndMutateRow_ValidateArguments <ArgumentException>( tableName, rowKey, RowFilters.PassAllFilter(), new[] { Mutations.DeleteFromRow() }, new[] { Mutations.DeleteFromRow() }); }
public async Task CheckAndMutateRow_Valid_Request() { var tableName = new TableName("project", "instance", "table"); await CheckAndMutateRow_ValidateArguments <RequestMadeException>( tableName, "abc", RowFilters.PassAllFilter(), new[] { Mutations.DeleteFromRow() }, new[] { Mutations.DeleteFromRow() }); }
private CheckAndMutateRowRequest ToMutateRowIfNotExistsRequest(IPersistentRepresentation persistent, ActorSystem system) { var request = new CheckAndMutateRowRequest(); request.TableNameAsTableName = _tableName; var payload = PersistentToBytes(persistent, system); request.PredicateFilter = RowFilters.PassAllFilter(); request.RowKey = ByteString.CopyFromUtf8(ToRowKeyString(persistent.PersistenceId, persistent.SequenceNr)); request.FalseMutations.Add(Mutations.SetCell(_family, PayloadColumnQualifier, payload, new BigtableVersion(-1))); return(request); }