Vou explicar como funcionam **classes de bônus** em programação, especialmente no contexto de jogos, sistemas de recompensa ou folha de pagamento.
## O que é uma Classe de Bônus?
É uma estrutura que define regras, cálculos e comportamentos relacionados a bônus, gratificações ou recompensas em um sistema.
## Estrutura Básica de uma Classe de Bônus
“`python
class Bonus:
def __init__(self, nome, tipo, valor_base, regras):
self.nome = nome
self.tipo = tipo # ‘percentual’, ‘fixo’, ‘por_meta’
self.valor_base = valor_base
self.regras = regras # condições para aplicar o bônus
def calcular(self, salario_base=None, desempenho=None, metas=None):
if self.tipo == ‘fixo’:
return self.valor_base
elif self.tipo == ‘percentual’ and salario_base:
return salario_base * (self.valor_base / 100)
elif self.tipo == ‘por_meta’ and metas:
return self.calcular_por_metas(metas)
return 0
def calcular_por_metas(self, metas):
# Lógica específica para metas
total = 0
for meta, valor in metas.items():
if meta in self.regras[‘metas_atingidas’]:
total += valor * self.regras[‘valor_por_meta’]
return total
“`
## Tipos Comuns de Bônus
### 1. **Bônus Fixo**
“`python
bonus_natal = Bonus(“13º”, “fixo”, 1000, {})
“`
### 2. **Bônus Percentual**
“`python
bonus_desempenho = Bonus(“PLR”, “percentual”, 15, {“minimo_avaliacao”: 7})
“`
### 3. **Bônus por Metas**
“`python
bonus_vendas = Bonus(“Comissão”, “por_meta”, 0, {
“valor_por_meta”: 50,
“metas”: [“venda_ouro”, “venda_prata”]
})
“`
## Sistema Completo de Bônus
“`python
class SistemaBonus:
def __init__(self):
self.bonus_disponiveis = []
def adicionar_bonus(self, bonus):
self.bonus_disponiveis.append(bonus)
def calcular_total_bonus(self, funcionario):
total = 0
for bonus in self.bonus_disponiveis:
if self.verificar_elegibilidade(bonus, funcionario):
total += bonus.calcular(
salario_base=funcionario.salario,
desempenho=funcionario.desempenho,
metas=funcionario.metas
)
return total
def verificar_elegibilidade(self, bonus, funcionario):
# Verifica se funcionário atende às regras
regras = bonus.regras
if ‘tempo_empresa’ in regras:
if funcionario.tempo_empresa < regras['tempo_empresa']:
return False
if 'minimo_avaliacao' in regras:
if funcionario.desempenho < regras['minimo_avaliacao']:
return False
return True
# Exemplo de uso
class Funcionario:
def __init__(self, nome, salario, tempo_empresa, desempenho):
self.nome = nome
self.salario = salario
self.tempo_empresa = tempo_empresa # em meses
self.desempenho = desempenho # 0-10
self.metas = {"vendas": 150000, "clientes_novos": 10}
# Configurando o sistema
sistema = SistemaBonus()
# Adicionando diferentes bônus
sistema.adicionar_bonus(Bonus(
"Anual por Tempo",
"percentual",
20,
{"tempo_empresa": 12}
))
sistema.adicionar_bonus(Bonus(
"Excelência",
"fixo",
5000,
{"minimo_avaliacao": 9}
))
# Calculando para um funcionário
func = Funcionario("João", 5000, 24, 9.5)
total_bonus = sistema.calcular_total_bonus(func)
print(f"Total de bônus: R$ {total_bonus:.2f}")
```
## Aplicações Práticas
### 1. **Folha de Pagamento**
```python
class FolhaPagamento:
def calcular_salario_total(self, funcionario, sistema_bonus):
salario_base = funcionario.salario
bonus = sistema_bonus.calcular_total_bonus(funcionario)
return salario_base + bonus
```
### 2. **Sistema de Recompensas em Jogos**
```python
class BonusJogo:
def __init__(self):
self.bonus_ativos = {}
def aplicar_bonus_temporario(self, tipo, valor, duracao):
# Bônus que duram X segundos/minutos
self.bonus_ativos[tipo] = {
'valor': valor,
'expira_em': time.time() + duracao
}
def calcular_dano(self, dano_base):
multiplicador = 1
if 'dano' in self.bonus_ativos:
multiplicador += self.bonus_ativos['dano']['valor']
return dano_base * multiplicador
```
### 3. **Programa de Fidelidade**
```python
class ProgramaFidelidade:
def __init__(self):
self.niveis = {
'bronze': {'desconto': 5, 'bonus_pontos': 1},
'prata': {'desconto': 10, 'bonus_pontos': 1.5},
'ouro': {'desconto': 15, 'bonus_pontos': 2}
}
def calcular_bonus_compra(self, cliente, valor_compra):
nivel = cliente.nivel_fidelidade
bonus = self.niveis[nivel]
desconto = valor_compra * (bonus['desconto'] / 100)
pontos = valor_compra * bonus['bonus_pontos']
return {'desconto': desconto, 'pontos': pontos}
```
## Boas Práticas
1. **Separação de Responsabilidades**
- Classe para regras de bônus
- Classe para cálculo
- Classe para elegibilidade
2. **Configuração Flexível**
- Use arquivos de configuração (JSON/YAML) para definir bônus
3. **Extensibilidade**
- Facilite adição de novos tipos de bônus
4. **Testabilidade**
- Crie testes unitários para cada tipo de cálculo
## Exemplo Avançado com Padrão Strategy
```python
from abc import ABC, abstractmethod
class EstrategiaBonus(ABC):
@abstractmethod
def calcular(self, contexto):
pass
class BonusPercentual(EstrategiaBonus):
def calcular(self, contexto):
return contexto['salario'] * (contexto['percentual'] / 100)
class BonusMetaCumprida(EstrategiaBonus):
def calcular(self, contexto):
if contexto['meta_atingida']:
return contexto['valor_fixo']
return 0
class BonusTempoServico(EstrategiaBonus):
def calcular(self, contexto):
anos = contexto['tempo_servico'] / 12
return contexto['salario'] * (min(anos, 5) * 0.02) # 2% por ano, até 5 anos
```
Essa abordagem permite maior flexibilidade e manutenção do código, especialmente em sistemas complexos com múltiplos tipos de bônus.
