More permissions refactoring and fixing most struct action transactions

Author: abstrct

x/structs/keeper/current_context.go

@@ -217,12 +217,6 @@ func (cc *CurrentContext) CommitAll() {
 
 
 
-
-
-
-
-
-
 	cc.committed = true
     /*
 	TODO
@@ -231,38 +225,3 @@ func (cc *CurrentContext) CommitAll() {
 	)
 	*/
 }
-
-// Reset clears all caches but keeps the context usable.
-// Useful for long-running operations (like ABCI hooks) that want to
-// commit periodically to avoid memory buildup.
-func (cc *CurrentContext) Reset() {
-	// Commit any pending changes first
-	if !cc.committed {
-		cc.CommitAll()
-	}
-
-	// Re-initialize all maps
-	cc.agreements = make(map[string]*AgreementCache)
-	cc.fleets = make(map[uint64]*FleetCache)
-	cc.guilds = make(map[string]*GuildCache)
-	cc.guildMembershipApps = make(map[string]*GuildMembershipApplicationCache)
-	cc.infusions = make(map[string]*InfusionCache)
-	cc.planets = make(map[string]*PlanetCache)
-	cc.players = make(map[string]*PlayerCache)
-	cc.providers = make(map[string]*ProviderCache)
-	cc.structs = make(map[string]*StructCache)
-	cc.substations = make(map[string]*SubstationCache)
-
-	cc.gridAttributes = make(map[string]*GridAttributeCache)
-	cc.structAttributes = make(map[string]*StructAttributeCache)
-	cc.planetAttributes = make(map[string]*PlanetAttributeCache)
-
-	cc.addresses = make(map[string]*AddressCache)
-	cc.allocations = make(map[string]*AllocationCache)
-	cc.permissions = make(map[string]*PermissionsCache)
-	cc.reactors = make(map[string]*ReactorCache)
-	cc.structTypes = make(map[uint64]*StructTypeCache)
-
-
-	cc.committed = false
-}

x/structs/keeper/msg_server_permission_set_on_address.go

@@ -40,7 +40,7 @@ func (k msgServer) PermissionSetOnAddress(goCtx context.Context, msg *types.MsgP
     }
 
     targetAddressPermissionId := GetAddressPermissionIDBytes(msg.Address)
-    cc.SetPermissions(targetAddressPermissionId, msg.Permissions)
+    cc.SetPermissions(targetAddressPermissionId, types.Permission(msg.Permissions))
 
 	return &types.MsgPermissionResponse{}, nil
 }

x/structs/keeper/msg_server_permission_set_on_object.go

@@ -43,7 +43,7 @@ func (k msgServer) PermissionSetOnObject(goCtx context.Context, msg *types.MsgPe
     }
 
     targetPlayerPermissionId := GetObjectPermissionIDBytes(msg.ObjectId, msg.PlayerId)
-    cc.SetPermissions(targetPlayerPermissionId, msg.Permissions)
+    cc.SetPermissions(targetPlayerPermissionId, types.Permission(msg.Permissions))
 
 	return &types.MsgPermissionResponse{}, nil
 }

x/structs/keeper/msg_server_struct_activate.go

@@ -26,25 +26,18 @@ func (k msgServer) StructActivate(goCtx context.Context, msg *types.MsgStructAct
         return &types.MsgStructStatusResponse{}, permissionError
     }
 
-    if structure.GetOwner().IsHalted() {
-        return &types.MsgStructStatusResponse{}, types.NewPlayerHaltedError(structure.GetOwnerId(), "struct_activate").WithStruct(msg.StructId)
-    }
-
     // Check Activation Readiness
         // Check Struct is Built
         // Check Struct is Offline
         // Check Player is Online
         // Check Player capacity
     readinessError := structure.ActivationReadinessCheck()
     if (readinessError != nil) {
-        k.DischargePlayer(ctx, structure.GetOwnerId())
         return &types.MsgStructStatusResponse{}, readinessError
     }
 
-    playerCharge := k.GetPlayerCharge(ctx, structure.GetOwnerId())
-    if (playerCharge < structure.GetStructType().GetActivateCharge()) {
-        k.DischargePlayer(ctx, structure.GetOwnerId())
-        return &types.MsgStructStatusResponse{}, types.NewInsufficientChargeError(structure.GetOwnerId(), structure.GetStructType().GetActivateCharge(), playerCharge, "activate").WithStructType(structure.GetTypeId()).WithStructId(msg.StructId)
+    if structure.GetOwner().GetCharge() < structure.GetStructType().ActivateCharge {
+        return &types.MsgStructStatusResponse{}, types.NewInsufficientChargeError(structure.GetOwnerId(), structure.GetStructType().ActivateCharge, structure.GetOwner().GetCharge(), "activate").WithStructType(structure.GetTypeId()).WithStructId(msg.StructId)
     }
 
     structure.GoOnline()

x/structs/keeper/msg_server_struct_attack.go

@@ -26,10 +26,6 @@ func (k msgServer) StructAttack(goCtx context.Context, msg *types.MsgStructAttac
 		return &types.MsgStructAttackResponse{}, permissionError
 	}
 
-	if structure.GetOwner().IsHalted() {
-		return &types.MsgStructAttackResponse{}, types.NewPlayerHaltedError(structure.GetOwnerId(), "struct_attack").WithStruct(msg.OperatingStructId)
-	}
-
 	// Is the Struct & Owner online?
 	readinessError := structure.ReadinessCheck()
 	if readinessError != nil {
@@ -50,9 +46,8 @@ func (k msgServer) StructAttack(goCtx context.Context, msg *types.MsgStructAttac
 		return &types.MsgStructAttackResponse{}, weaponSystemError
 	}
 
-	playerCharge := k.GetPlayerCharge(ctx, structure.GetOwnerId())
-	if playerCharge < structure.GetStructType().GetWeaponCharge(weaponSystem) {
-		return &types.MsgStructAttackResponse{}, types.NewInsufficientChargeError(structure.GetOwnerId(), structure.GetStructType().GetWeaponCharge(weaponSystem), playerCharge, "attack").WithStructType(structure.GetTypeId())
+	if structure.GetOwner().GetCharge() < structure.GetStructType().GetWeaponCharge(weaponSystem) {
+		return &types.MsgStructAttackResponse{}, types.NewInsufficientChargeError(structure.GetOwnerId(), structure.GetStructType().GetWeaponCharge(weaponSystem), structure.GetOwner().GetCharge(), "attack").WithStructType(structure.GetTypeId())
 	}
 
 	// Jump out of Stealth Mode for the attack
@@ -115,7 +110,6 @@ func (k msgServer) StructAttack(goCtx context.Context, msg *types.MsgStructAttac
 		if (structure.GetStructType().GetWeaponBlockable(weaponSystem)) || (structure.GetStructType().GetWeaponCounterable(weaponSystem)) {
 
 			// Check the Defenders
-			defenderPlayer := targetStructure.GetOwner()
 			defenders := targetStructure.GetDefenders()
 			for _, defender := range defenders {
 				k.logger.Info("Defender at Location", "defender", defender.GetStructId(), "locationId", defender.GetLocationId())
@@ -124,7 +118,6 @@ func (k msgServer) StructAttack(goCtx context.Context, msg *types.MsgStructAttac
 				defender = cc.GetStruct(defender.GetStructId())
 
 				defender.Defender = true
-				defender.ManualLoadOwner(defenderPlayer)
 				defender.ManualLoadEventAttackDetail(eventAttackDetail)
 				defender.ManualLoadEventAttackShotDetail(eventAttackShotDetail)
 
@@ -168,7 +161,7 @@ func (k msgServer) StructAttack(goCtx context.Context, msg *types.MsgStructAttac
 
 		structure.GetEventAttackDetail().AppendShot(targetStructure.FlushEventAttackShotDetail())
 
-		if targetStructure.GetStructType().GetCategory() == types.ObjectType_planet {
+		if targetStructure.GetStructType().Category == types.ObjectType_planet {
 			targetWasPlanetary = true
 			targetWasOnPlanet = targetStructure.GetPlanet()
 		}
@@ -187,7 +180,7 @@ func (k msgServer) StructAttack(goCtx context.Context, msg *types.MsgStructAttac
 
 	_ = ctx.EventManager().EmitTypedEvent(&types.EventAttack{EventAttackDetail: eventAttackDetail})
 
-	k.DischargePlayer(ctx, structure.GetOwnerId())
+    structure.GetOwner().Discharge()
 
 	if ctx.ExecMode() == sdk.ExecModeCheck {
 		//ctx.GasMeter().RefundGas(ctx.GasMeter().GasConsumed(), "Walkin it back")

x/structs/keeper/msg_server_struct_build_complete.go

@@ -32,10 +32,6 @@ func (k msgServer) StructBuildComplete(goCtx context.Context, msg *types.MsgStru
 		return &types.MsgStructStatusResponse{}, types.NewObjectNotFoundError("struct", msg.StructId)
 	}
 
-	if structure.GetOwner().IsHalted() {
-		return &types.MsgStructStatusResponse{}, types.NewPlayerHaltedError(structure.GetOwnerId(), "struct_build_complete").WithStruct(msg.StructId)
-	}
-
 	if structure.IsBuilt() {
 		//structure.GetOwner().Discharge()
 		//structure.GetOwner().Commit()

x/structs/keeper/msg_server_struct_build_initiate.go

@@ -35,28 +35,22 @@ func (k msgServer) StructBuildInitiate(goCtx context.Context, msg *types.MsgStru
         return &types.MsgStructStatusResponse{}, permissionError
     }
 
-    if owner.IsHalted() {
-        return &types.MsgStructStatusResponse{}, types.NewPlayerHaltedError(msg.PlayerId, "struct_build_initiate")
-    }
-
     // Load the Struct Type
-    structType, structTypeFound := k.GetStructType(ctx, msg.StructTypeId)
+    structType, structTypeFound := cc.GetStructType(msg.StructTypeId)
     if !structTypeFound {
         return &types.MsgStructStatusResponse{}, types.NewObjectNotFoundError("struct_type", "").WithIndex(msg.StructTypeId)
     }
 
     // Check that the player can build more of this type of Struct
-    if (structType.GetBuildLimit() > 0) {
-        if (owner.GetBuiltQuantity(msg.StructTypeId) >= structType.GetBuildLimit()) {
-            owner.Discharge()
-            return &types.MsgStructStatusResponse{}, types.NewPlayerPowerError(owner.GetPlayerId(), "capacity_exceeded").WithCapacity(structType.GetBuildLimit(), owner.GetBuiltQuantity(msg.StructTypeId))
+    if (structType.GetStructType().BuildLimit > 0) {
+        if (owner.GetBuiltQuantity(msg.StructTypeId) >= structType.GetStructType().BuildLimit) {
+            return &types.MsgStructStatusResponse{}, types.NewPlayerPowerError(owner.GetPlayerId(), "capacity_exceeded").WithCapacity(structType.GetStructType().BuildLimit, owner.GetBuiltQuantity(msg.StructTypeId))
         }
     }
 
     // Check Player Charge
-    if (owner.GetCharge() < structType.BuildCharge) {
-        err := types.NewInsufficientChargeError(owner.GetPlayerId(), structType.BuildCharge, owner.GetCharge(), "build").WithStructType(msg.StructTypeId)
-        owner.Discharge()
+    if (owner.GetCharge() < structType.GetStructType().BuildCharge) {
+        err := types.NewInsufficientChargeError(owner.GetPlayerId(), structType.GetStructType().BuildCharge, owner.GetCharge(), "build").WithStructType(msg.StructTypeId)
         return &types.MsgStructStatusResponse{}, err
     }
 
@@ -66,21 +60,17 @@ func (k msgServer) StructBuildInitiate(goCtx context.Context, msg *types.MsgStru
     }
 
 
-    if !owner.CanSupportLoadAddition(structType.BuildDraw) {
-        owner.Discharge()
-        return &types.MsgStructStatusResponse{}, types.NewPlayerPowerError(owner.GetPlayerId(), "capacity_exceeded").WithCapacity(structType.BuildDraw, owner.GetAvailableCapacity())
+    if !owner.CanSupportLoadAddition(structType.GetStructType().BuildDraw) {
+        return &types.MsgStructStatusResponse{}, types.NewPlayerPowerError(owner.GetPlayerId(), "capacity_exceeded").WithCapacity(structType.GetStructType().BuildDraw, owner.GetAvailableCapacity())
     }
 
-
-    k.logger.Info("Struct Materializing", "structType", structType.Type, "ambit", msg.OperatingAmbit, "slot", msg.Slot)
-    structure, err := k.InitiateStruct(ctx, msg.Creator, owner, &structType, msg.OperatingAmbit, msg.Slot)
+    k.logger.Info("Struct Materializing", "structType", structType.GetStructType().Type, "ambit", msg.OperatingAmbit, "slot", msg.Slot)
+    structure, err := cc.InitiateStruct(msg.Creator, owner, structType, msg.OperatingAmbit, msg.Slot)
     if (err != nil) {
         return &types.MsgStructStatusResponse{}, err
     }
-    cc.RegisterStruct(&structure)
 
     owner.Discharge()
 
-
 	return &types.MsgStructStatusResponse{Struct: structure.GetStruct()}, nil
 }

x/structs/keeper/msg_server_struct_deactivate.go

@@ -26,21 +26,15 @@ func (k msgServer) StructDeactivate(goCtx context.Context, msg *types.MsgStructD
         return &types.MsgStructStatusResponse{}, permissionError
     }
 
-    if structure.GetOwner().IsHalted() {
-        return &types.MsgStructStatusResponse{}, types.NewPlayerHaltedError(structure.GetOwnerId(), "struct_deactivate").WithStruct(msg.StructId)
-    }
-
     if !structure.LoadStruct(){
         return &types.MsgStructStatusResponse{}, types.NewObjectNotFoundError("struct", msg.StructId)
     }
 
     if !structure.IsBuilt() {
-        structure.GetOwner().Discharge()
         return &types.MsgStructStatusResponse{}, types.NewStructStateError(msg.StructId, "building", "built", "deactivate")
     }
 
     if structure.IsOffline() {
-        structure.GetOwner().Discharge()
         return &types.MsgStructStatusResponse{}, types.NewStructStateError(msg.StructId, "offline", "online", "deactivate")
     }
 

x/structs/keeper/msg_server_struct_defense_clear.go

@@ -34,24 +34,17 @@ func (k msgServer) StructDefenseClear(goCtx context.Context, msg *types.MsgStruc
         return &types.MsgStructStatusResponse{}, types.NewObjectNotFoundError("struct", msg.DefenderStructId)
     }
 
-    if structure.GetOwner().IsHalted() {
-        return &types.MsgStructStatusResponse{}, types.NewPlayerHaltedError(structure.GetOwnerId(), "defense_clear").WithStruct(msg.DefenderStructId)
-    }
-
     if structure.IsOffline() {
-        structure.GetOwner().Discharge()
         return &types.MsgStructStatusResponse{}, types.NewStructStateError(msg.DefenderStructId, "offline", "online", "defense_clear")
     }
 
     if !structure.IsCommandable() {
-        structure.GetOwner().Discharge()
         return &types.MsgStructStatusResponse{}, types.NewFleetCommandError(structure.GetStructId(), "no_command_struct")
     }
 
     // Check Player Charge
     if (structure.GetOwner().GetCharge() < structure.GetStructType().DefendChangeCharge) {
         err := types.NewInsufficientChargeError(structure.GetOwnerId(), structure.GetStructType().DefendChangeCharge, structure.GetOwner().GetCharge(), "defend").WithStructType(structure.GetStructType().Id)
-        structure.GetOwner().Discharge()
         return &types.MsgStructStatusResponse{}, err
     }
 
@@ -61,7 +54,6 @@ func (k msgServer) StructDefenseClear(goCtx context.Context, msg *types.MsgStruc
 
     protectedStructIndex := k.GetStructAttribute(ctx, GetStructAttributeIDByObjectId(types.StructAttributeType_protectedStructIndex, msg.DefenderStructId))
     if (protectedStructIndex == 0) {
-        structure.GetOwner().Discharge()
         return &types.MsgStructStatusResponse{}, types.NewStructStateError(msg.DefenderStructId, "not_defending", "defending", "defense_clear")
     }
     protectedStructId := GetObjectID(types.ObjectType_struct, protectedStructIndex)

x/structs/keeper/msg_server_struct_defense_set.go

@@ -43,24 +43,17 @@ func (k msgServer) StructDefenseSet(goCtx context.Context, msg *types.MsgStructD
         return &types.MsgStructStatusResponse{}, types.NewObjectNotFoundError("struct", msg.DefenderStructId)
     }
 
-    if structure.GetOwner().IsHalted() {
-        return &types.MsgStructStatusResponse{}, types.NewPlayerHaltedError(structure.GetOwnerId(), "defense_set").WithStruct(msg.DefenderStructId)
-    }
-
     if structure.IsOffline() {
-        structure.GetOwner().Discharge()
         return &types.MsgStructStatusResponse{}, types.NewStructStateError(msg.DefenderStructId, "offline", "online", "defense_set")
     }
 
     if !structure.IsCommandable() {
-        k.DischargePlayer(ctx, structure.GetOwnerId())
         return &types.MsgStructStatusResponse{}, types.NewFleetCommandError(structure.GetStructId(), "no_command_struct")
     }
 
     // Check Player Charge
     if (structure.GetOwner().GetCharge() < structure.GetStructType().DefendChangeCharge) {
         err := types.NewInsufficientChargeError(structure.GetOwnerId(), structure.GetStructType().DefendChangeCharge, structure.GetOwner().GetCharge(), "defend").WithStructType(structure.GetStructType().Id)
-        structure.GetOwner().Discharge()
         return &types.MsgStructStatusResponse{}, err
     }
 
@@ -99,11 +92,9 @@ func (k msgServer) StructDefenseSet(goCtx context.Context, msg *types.MsgStructD
     }
 
     if (!inRange) {
-        structure.GetOwner().Discharge()
         return &types.MsgStructStatusResponse{}, types.NewStructLocationError(structure.GetStructType().Id, "", "not_in_range").WithStruct(structure.GetStructId()).WithLocation("struct", msg.ProtectedStructId)
     }
 
-
     k.SetStructDefender(ctx, msg.ProtectedStructId, protectedStructure.Index, structure.GetStructId())
 
     structure.GetOwner().Discharge()