|
|
--- |
|
|
license: mit |
|
|
--- |
|
|
|
|
|
|
|
|
# crocobras |
|
|
|
|
|
 |
|
|
|
|
|
Le cœur logique du jeu "Le bras d'un mec", un jeu où vous combattez des crocodiles pour protéger un bras ! |
|
|
Ce package Node.js fournit toutes les règles, la logique, et la gestion d'état nécessaires pour construire votre propre version du jeu. **Il ne contient PAS de graphiques, de sons ou de logique d'interface utilisateur (UI)**. C'est à vous, le développeur, de construire l'expérience visuelle et sonore ! |
|
|
|
|
|
Développé par [nekoclem](https://github.com/nekoclem). |
|
|
|
|
|
## Fonctionnalités principales |
|
|
|
|
|
* Gestion des niveaux et de la progression. |
|
|
* Calcul du nombre de crocodiles par niveau. |
|
|
* Gestion de la vie du bras et du "Game Over". |
|
|
* Détection des événements clés du jeu (coup de feu, crocodile tué, bras mangé, changement de niveau). |
|
|
* Options de personnalisation pour adapter le jeu à votre vision. |
|
|
|
|
|
### Fonctionnalités v1.1.0 |
|
|
* **Système de power-ups personnalisés** avec `crocopow` |
|
|
* **Système de boosts temporaires** avec `crocoboost` |
|
|
* **Système de points de vie pour crocodiles** avec `crocolife` |
|
|
* **Système d'armure/force des crocodiles** avec `crocoarmure` |
|
|
* **Personnalisation de la vitesse des crocodiles** avec `crocorap` |
|
|
* **Système de danse/esquive** avec `crocopop` |
|
|
* **Explosions de crocodiles** avec `crocoexplose` |
|
|
|
|
|
### Fonctionnalités v1.2.0 |
|
|
* **Système de combos** avec `crocom` pour des effets spéciaux en chaîne |
|
|
* **Modes de jeux personnalisés** avec `crocomode` pour créer des défis uniques |
|
|
* **Armures spécialisées** avec `crocorpes` aux propriétés avancées |
|
|
* **Système de dialogues** avec `crocodial` pour des interactions narratives |
|
|
* **Missions et quêtes** avec `crocomise` avec récompenses personnalisées |
|
|
* **Système économique complet** avec `crocomons` (monnaie et boutique) |
|
|
* **Environnements dynamiques** avec `crocodym` pour des changements de terrain |
|
|
* **Personnalisation d'assets** avec `crocopay` pour les apparences |
|
|
* **IA avancée des crocodiles** avec `crocia` pour des comportements intelligents |
|
|
* **Collectibles et succès** avec `crocohab` pour la progression |
|
|
* **Messages créatifs** avec `crocotive` pour des dialogues immersifs |
|
|
* **Personnages personnalisés** avec `croconage` pour enrichir l'univers |
|
|
|
|
|
### 🆕 Nouveautés v1.3.0 |
|
|
* **Quêtes dynamiques adaptatives** avec `crocojom` - Missions qui s'adaptent aux choix des joueurs |
|
|
* **Système climatique interactif** avec `crocera` - Climat qui affecte le comportement des crocodiles et du bras |
|
|
* **Événements spéciaux conditionnels** avec `crocogiw` - Crocodiles/événements rares selon des conditions |
|
|
* **IA avancée avec prise de décision** avec `crocorin` - Comportements IA personnalisés et adaptatifs |
|
|
* **Analyse de données de jeu** avec `crocomp` - Système d'analytics personnalisé |
|
|
* **Fonctions JavaScript personnalisées** avec `crocotina` - Créez vos propres fonctions intégrées |
|
|
* **Mini-jeux de quiz créatifs** avec `crocofaf` - Quiz pour gagner points/monnaie/kills |
|
|
* **Messages temporaires personnalisés** avec `crocojup` - Notifications temporaires configurables |
|
|
* **Power-ups temporaires avancés** avec `crocodae` - System de buffs temporaires personnalisés |
|
|
* **Logs personnalisés créatifs** avec `crocolog` - Système de logging avec formes et couleurs |
|
|
* **Clonage et invocation de crocodiles** avec `crocojust` - Duplication et invocation de crocodiles |
|
|
* **Crocodiles rares spéciaux** avec `crocorare` - Crocodiles légendaires avec comportements uniques |
|
|
* **Tutoriels interactifs** avec `crocomd` - Mini-tutoriels de démarrage par dialogues |
|
|
* **Personnalisation comportementale** avec `crocoglop` - Comportements et messages spéciaux par crocodile |
|
|
* **Système de bébés crocodiles** avec `crocofarm` - Naissance et croissance de jeunes crocodiles |
|
|
* **Système d'envies des crocodiles** avec `crocenvie` - Motivations complexes au-delà de manger le bras |
|
|
|
|
|
## Installation |
|
|
|
|
|
```bash |
|
|
npm install crocobras |
|
|
``` |
|
|
|
|
|
Assurez-vous d'avoir également nekomaths installé, car crocobras en dépend : |
|
|
|
|
|
```bash |
|
|
npm install nekomaths |
|
|
``` |
|
|
|
|
|
## Utilisation de base |
|
|
|
|
|
crocobras exporte une classe CrocobrasGame. Vous devez instancier cette classe pour commencer à utiliser la logique du jeu. |
|
|
|
|
|
```javascript |
|
|
const CrocobrasGame = require('crocobras'); |
|
|
|
|
|
// Créez une nouvelle instance du jeu. |
|
|
const game = new CrocobrasGame({ |
|
|
initialArmHealth: 200, // Le bras est plus résistant ! |
|
|
crocoDamage: 20, // Moins de dégâts par croco |
|
|
crocoPerLevel: 2, // Plus de crocos par niveau |
|
|
levelUpThreshold: 10 // 10 crocos pour passer de niveau |
|
|
}); |
|
|
|
|
|
// Écoutez les événements du jeu |
|
|
game.on('gameStarted', (data) => { |
|
|
console.log(`Partie démarrée ! Niveau: ${data.level}, Vie du bras: ${data.armHealth}`); |
|
|
}); |
|
|
|
|
|
game.on('crocoKilled', (data) => { |
|
|
console.log(`Un croco tué ! Restant : ${data.remainingCount}/${data.killedCount + data.remainingCount}`); |
|
|
}); |
|
|
|
|
|
// Démarrer le jeu |
|
|
game.startGame(); |
|
|
``` |
|
|
|
|
|
## 🆕 Nouvelles fonctionnalités v1.3.0 |
|
|
|
|
|
### `crocojom(questId, questData, questLogic)` - Quêtes dynamiques adaptatives |
|
|
|
|
|
Créez des quêtes qui s'adaptent aux choix des joueurs en temps réel. |
|
|
|
|
|
```javascript |
|
|
// Quête qui change selon les choix du joueur |
|
|
game.crocojom('adaptive_quest', { |
|
|
title: 'Le Mystère du Marécage', |
|
|
branches: { |
|
|
start: { text: 'Vous entrez dans le marécage...', choices: ['explorer', 'fuir'] }, |
|
|
explorer: { text: 'Vous découvrez une grotte mystérieuse', choices: ['entrer', 'contourner'] }, |
|
|
fuir: { text: 'Vous rebroussez chemin mais...', choices: ['courage', 'panic'] } |
|
|
}, |
|
|
rewards: { coins: 100, experience: 50 } |
|
|
}, function(questData, progress, action, choice) { |
|
|
if (action === 'choice') { |
|
|
if (choice.action === 'explorer') { |
|
|
// Augmenter la difficulté mais aussi les récompenses |
|
|
this.settings.crocoPerLevel += 1; |
|
|
questData.rewards.coins *= 1.5; |
|
|
return { newBranch: 'explorer', difficulty: 'increased' }; |
|
|
} else if (choice.action === 'fuir') { |
|
|
// Chemin plus sûr mais moins récompensé |
|
|
questData.rewards.coins *= 0.8; |
|
|
return { newBranch: 'fuir', difficulty: 'reduced' }; |
|
|
} |
|
|
} |
|
|
}); |
|
|
|
|
|
// Démarrer la quête |
|
|
game.startDynamicQuest('adaptive_quest'); |
|
|
|
|
|
// Faire un choix |
|
|
game.makeDynamicQuestChoice('adaptive_quest', { action: 'explorer' }); |
|
|
``` |
|
|
|
|
|
### `crocera(weatherId, weatherData, weatherLogic)` - Système climatique interactif |
|
|
|
|
|
Créez des conditions météorologiques qui influencent le gameplay. |
|
|
|
|
|
```javascript |
|
|
// Tempête qui rend les crocodiles plus agressifs mais ralentit le joueur |
|
|
game.crocera('storm', { |
|
|
name: 'Tempête Électrique', |
|
|
duration: 30000, // 30 secondes |
|
|
intensity: 0.8, |
|
|
crocodileEffects: { speed: 1.3, aggression: 1.5 }, |
|
|
armEffects: { visibility: 0.6, movement: 0.7 } |
|
|
}, function(weatherData, gameState) { |
|
|
console.log(`⛈️ ${weatherData.name} activée !`); |
|
|
|
|
|
// Effet sur les crocodiles existants |
|
|
if (this.crocodileSpeeds) { |
|
|
Object.keys(this.crocodileSpeeds).forEach(crocoId => { |
|
|
const currentSpeed = this.crocodileSpeeds[crocoId].currentSpeed; |
|
|
this.crocodileSpeeds[crocoId].currentSpeed = currentSpeed * weatherData.crocodileEffects.speed; |
|
|
}); |
|
|
} |
|
|
|
|
|
// Réduire la visibilité du joueur |
|
|
this.emit('weatherEffect', { |
|
|
type: 'visibility', |
|
|
value: weatherData.armEffects.visibility |
|
|
}); |
|
|
|
|
|
// Éclairs aléatoires |
|
|
const lightningInterval = setInterval(() => { |
|
|
if (this.currentWeather === 'storm') { |
|
|
if (Math.random() < 0.2) { |
|
|
// Éclair aide le joueur (tue un crocodile) |
|
|
this.crocokill(); |
|
|
console.log('⚡ Un éclair élimine un crocodile !'); |
|
|
} |
|
|
} else { |
|
|
clearInterval(lightningInterval); |
|
|
} |
|
|
}, 3000); |
|
|
}); |
|
|
|
|
|
// Activer la tempête |
|
|
game.activateWeather('storm'); |
|
|
``` |
|
|
|
|
|
### `crocogiw(specialId, specialData, specialLogic)` - Événements spéciaux conditionnels |
|
|
|
|
|
Créez des crocodiles ou événements rares qui n'apparaissent que dans certaines conditions. |
|
|
|
|
|
```javascript |
|
|
// Crocodile boss qui n'apparaît qu'au niveau 5+ avec moins de 50% de vie |
|
|
game.crocogiw('boss_croco', { |
|
|
type: 'crocodile', |
|
|
rarity: 'legendary', |
|
|
triggerConditions: { |
|
|
minLevel: 5, |
|
|
maxArmHealthPercent: 0.5 |
|
|
}, |
|
|
rewards: { coins: 500, experience: 200 } |
|
|
}, function(specialData, gameState) { |
|
|
const healthPercent = gameState.armHealth / this.settings.initialArmHealth; |
|
|
const meetsConditions = gameState.currentLevel >= specialData.triggerConditions.minLevel && |
|
|
healthPercent <= specialData.triggerConditions.maxArmHealthPercent; |
|
|
|
|
|
if (meetsConditions && Math.random() < 0.1) { // 10% de chance |
|
|
console.log('👑 BOSS CROCODILE LÉGENDAIRE APPARAÎT !'); |
|
|
|
|
|
// Créer un super crocodile |
|
|
this.crocolife(999, 300); // 300 HP |
|
|
this.crocoarmure(999, 50); // Armure élevée |
|
|
this.crocia(999, 'legendary_boss', (aiData) => { |
|
|
return { action: 'ultimate_attack', newState: 'berserker' }; |
|
|
}); |
|
|
|
|
|
return true; // Déclencher l'événement |
|
|
} |
|
|
|
|
|
return false; |
|
|
}); |
|
|
|
|
|
// Vérifier les événements spéciaux à chaque kill |
|
|
game.on('crocoKilled', () => { |
|
|
game.checkSpecialElements(); |
|
|
}); |
|
|
``` |
|
|
|
|
|
### `crocorin(crocoId, aiConfig, decisionLogic)` - IA avancée avec prise de décision |
|
|
|
|
|
Créez des IA qui apprennent et s'adaptent au comportement du joueur. |
|
|
|
|
|
```javascript |
|
|
// IA qui apprend les patterns de tir du joueur |
|
|
game.crocorin(1, { |
|
|
learningRate: 0.15, |
|
|
memorySize: 30, |
|
|
personalityTraits: { patience: 0.7, cunning: 0.9 }, |
|
|
decisionFrequency: 2000 |
|
|
}, function(aiData) { |
|
|
const { crocoId, memory, gameState, situation, learningData } = aiData; |
|
|
|
|
|
// Analyser les patterns de tir du joueur |
|
|
const recentShots = memory.filter(m => m.type === 'decision' && m.timestamp > Date.now() - 10000); |
|
|
const shotPattern = recentShots.length > 0 ? recentShots.reduce((acc, shot) => { |
|
|
const interval = shot.timestamp - (recentShots[recentShots.indexOf(shot) - 1]?.timestamp || shot.timestamp); |
|
|
acc.push(interval); |
|
|
return acc; |
|
|
}, []) : []; |
|
|
|
|
|
const avgShotInterval = shotPattern.length > 0 ? |
|
|
shotPattern.reduce((a, b) => a + b, 0) / shotPattern.length : 3000; |
|
|
|
|
|
// Décision basée sur l'apprentissage |
|
|
if (avgShotInterval < 1500) { |
|
|
// Joueur tire rapidement -> être plus défensif |
|
|
return { |
|
|
action: 'defensive_pattern', |
|
|
strategy: 'zigzag', |
|
|
confidence: 0.8 |
|
|
}; |
|
|
} else if (gameState.armHealth < 30) { |
|
|
// Bras faible -> attaque coordonnée |
|
|
return { |
|
|
action: 'final_assault', |
|
|
strategy: 'aggressive_rush', |
|
|
confidence: 0.95 |
|
|
}; |
|
|
} else { |
|
|
// Comportement adaptatif |
|
|
return { |
|
|
action: 'adaptive_hunt', |
|
|
strategy: 'patient_stalking', |
|
|
confidence: 0.6 |
|
|
}; |
|
|
} |
|
|
}); |
|
|
|
|
|
// Mettre à jour l'IA régulièrement |
|
|
setInterval(() => { |
|
|
if (game.isGameRunning) { |
|
|
game.executeAdvancedAIDecision(1, { |
|
|
playerActivity: 'shooting', |
|
|
timeElapsed: Date.now() |
|
|
}); |
|
|
} |
|
|
}, 2000); |
|
|
``` |
|
|
|
|
|
### `crocomp(analysisId, analysisConfig, analysisLogic)` - Analyse de données de jeu |
|
|
|
|
|
Analysez les performances et comportements des joueurs. |
|
|
|
|
|
```javascript |
|
|
// Système d'analyse de la performance du joueur |
|
|
game.crocomp('player_performance', { |
|
|
dataPoints: ['accuracy', 'survival_time', 'level_progression', 'death_causes'], |
|
|
updateInterval: 10000, // Toutes les 10 secondes |
|
|
reportFormat: 'detailed' |
|
|
}, function(analysisData) { |
|
|
const { gameState, analyticsData, previousReports } = analysisData; |
|
|
|
|
|
// Calculer la précision |
|
|
const totalShots = this.totalShots || 0; |
|
|
const totalKills = this.killedCrocodilesThisLevel || 0; |
|
|
const accuracy = totalShots > 0 ? (totalKills / totalShots) * 100 : 0; |
|
|
|
|
|
// Temps de survie |
|
|
const survivalTime = this.gameStartTime ? Date.now() - this.gameStartTime : 0; |
|
|
|
|
|
// Analyser les tendances |
|
|
const report = { |
|
|
timestamp: Date.now(), |
|
|
accuracy: accuracy, |
|
|
survivalTime: survivalTime, |
|
|
currentLevel: gameState.currentLevel, |
|
|
armHealth: gameState.armHealth, |
|
|
recommendations: [] |
|
|
}; |
|
|
|
|
|
// Recommandations basées sur les performances |
|
|
if (accuracy < 50) { |
|
|
report.recommendations.push('Améliorer la précision de tir'); |
|
|
} |
|
|
if (gameState.armHealth < 50) { |
|
|
report.recommendations.push('Jouer plus défensivement'); |
|
|
} |
|
|
if (gameState.currentLevel > 3 && accuracy > 80) { |
|
|
report.recommendations.push('Excellent ! Continuez ainsi !'); |
|
|
} |
|
|
|
|
|
console.log(`📊 Rapport de performance: Précision ${accuracy.toFixed(1)}%, Niveau ${gameState.currentLevel}`); |
|
|
|
|
|
return report; |
|
|
}); |
|
|
|
|
|
// Lancer l'analyse automatique |
|
|
setInterval(() => { |
|
|
if (game.isGameRunning) { |
|
|
game.runGameAnalysis('player_performance'); |
|
|
} |
|
|
}, 10000); |
|
|
``` |
|
|
|
|
|
### `crocotina(functionName, customFunction, options)` - Fonctions JavaScript personnalisées |
|
|
|
|
|
Intégrez vos propres fonctions directement dans le moteur de jeu. |
|
|
|
|
|
```javascript |
|
|
// Fonction personnalisée pour calculer des bonus de score |
|
|
game.crocotina('calculateScoreBonus', function(baseScore, multiplier, levelBonus) { |
|
|
const bonus = baseScore * multiplier + (this.currentLevel * levelBonus); |
|
|
this.emit('scoreBonusCalculated', { baseScore, multiplier, levelBonus, bonus }); |
|
|
return Math.floor(bonus); |
|
|
}, { |
|
|
description: 'Calcule les bonus de score avec multiplicateurs', |
|
|
parameters: ['baseScore', 'multiplier', 'levelBonus'], |
|
|
category: 'scoring' |
|
|
}); |
|
|
|
|
|
// Fonction de téléportation d'urgence du bras |
|
|
game.crocotina('emergencyArmTeleport', function(safetyThreshold = 20) { |
|
|
if (this.armHealth <= safetyThreshold) { |
|
|
const oldHealth = this.armHealth; |
|
|
this.armHealth = Math.min(this.armHealth + 30, this.settings.initialArmHealth); |
|
|
|
|
|
console.log(`🚨 Téléportation d'urgence ! Vie: ${oldHealth} → ${this.armHealth}`); |
|
|
this.emit('emergencyTeleport', { oldHealth, newHealth: this.armHealth }); |
|
|
|
|
|
return { success: true, healthRestored: this.armHealth - oldHealth }; |
|
|
} |
|
|
|
|
|
return { success: false, reason: 'Seuil de sécurité non atteint' }; |
|
|
}, { |
|
|
description: 'Téléporte le bras en sécurité si la vie est critique', |
|
|
parameters: ['safetyThreshold'], |
|
|
category: 'emergency' |
|
|
}); |
|
|
|
|
|
// Utiliser les fonctions personnalisées |
|
|
const scoreBonus = game.executeCustomFunction('calculateScoreBonus', 100, 1.5, 10); |
|
|
const teleportResult = game.executeCustomFunction('emergencyArmTeleport', 25); |
|
|
|
|
|
console.log(`Bonus calculé: ${scoreBonus}`); |
|
|
console.log(`Téléportation: ${teleportResult.success ? 'Réussie' : 'Échouée'}`); |
|
|
``` |
|
|
|
|
|
### `crocofaf(quizId, quizData, quizLogic)` - Mini-jeux de quiz créatifs |
|
|
|
|
|
Créez des quiz pour gagner des récompenses en tuant des crocodiles. |
|
|
|
|
|
```javascript |
|
|
// Quiz sur les crocodiles pour gagner des kills bonus |
|
|
game.crocofaf('croco_quiz', { |
|
|
title: 'Quiz des Crocodiles', |
|
|
questions: [ |
|
|
{ |
|
|
question: 'Combien de dents a un crocodile adulte ?', |
|
|
answers: ['24', '64', '80', '32'], |
|
|
correct: 2, // Index de la bonne réponse |
|
|
killReward: 3 |
|
|
}, |
|
|
{ |
|
|
question: 'Dans quel milieu vivent les crocodiles ?', |
|
|
answers: ['Désert', 'Forêt', 'Zones humides', 'Montagne'], |
|
|
correct: 2, |
|
|
killReward: 2 |
|
|
}, |
|
|
{ |
|
|
question: 'Quelle est la vitesse maximale d\'un crocodile sur terre ?', |
|
|
answers: ['15 km/h', '25 km/h', '35 km/h', '45 km/h'], |
|
|
correct: 1, |
|
|
killReward: 4 |
|
|
} |
|
|
], |
|
|
timeLimit: 15000, // 15 secondes par question |
|
|
rewards: { coins: 50, experience: 25 } |
|
|
}, function(quizData, action, context) { |
|
|
if (action === 'start') { |
|
|
console.log(`🧠 ${quizData.title} commence !`); |
|
|
this.emit('quizQuestionReady', { |
|
|
question: quizData.questions[0], |
|
|
timeLimit: quizData.timeLimit |
|
|
}); |
|
|
} else if (action === 'answer') { |
|
|
const question = quizData.questions[context.currentQuestion]; |
|
|
const isCorrect = context.answer === question.correct; |
|
|
|
|
|
if (isCorrect) { |
|
|
console.log(`✅ Bonne réponse ! ${question.killReward} crocodiles éliminés !`); |
|
|
|
|
|
// Tuer des crocodiles comme récompense |
|
|
for (let i = 0; i < question.killReward; i++) { |
|
|
this.crocokill(); |
|
|
} |
|
|
|
|
|
return { |
|
|
correct: true, |
|
|
points: question.killReward, |
|
|
message: `${question.killReward} crocodiles éliminés !` |
|
|
}; |
|
|
} else { |
|
|
console.log(`❌ Mauvaise réponse... La bonne réponse était: ${question.answers[question.correct]}`); |
|
|
return { |
|
|
correct: false, |
|
|
points: 0, |
|
|
message: 'Aucune récompense cette fois.' |
|
|
}; |
|
|
} |
|
|
} |
|
|
}); |
|
|
|
|
|
// Démarrer le quiz |
|
|
game.startMiniGame('croco_quiz'); |
|
|
|
|
|
// Répondre à une question |
|
|
game.answerQuizQuestion('croco_quiz', 2); // Réponse C |
|
|
``` |
|
|
|
|
|
### `crocojup(messageId, messageData, messageLogic)` - Messages temporaires personnalisés |
|
|
|
|
|
Affichez des notifications temporaires personnalisées. |
|
|
|
|
|
```javascript |
|
|
// Message de félicitations pour les level ups |
|
|
game.crocojup('levelup_celebration', { |
|
|
text: 'NIVEAU SUPÉRIEUR !', |
|
|
duration: 3000, |
|
|
style: { color: 'gold', size: 'large', effect: 'glow' }, |
|
|
position: 'center', |
|
|
animation: 'bounce' |
|
|
}, function(messageData, context) { |
|
|
const level = context.level || this.currentLevel; |
|
|
const customText = `🎉 NIVEAU ${level} ATTEINT ! 🎉`; |
|
|
|
|
|
this.emit('celebrationMessage', { |
|
|
text: customText, |
|
|
style: messageData.style, |
|
|
position: messageData.position, |
|
|
animation: messageData.animation |
|
|
}); |
|
|
|
|
|
// Animation de bonus |
|
|
if (level % 5 === 0) { |
|
|
// Tous les 5 niveaux, message spécial |
|
|
setTimeout(() => { |
|
|
this.showTemporaryMessage('milestone_bonus', { level }); |
|
|
}, 1500); |
|
|
} |
|
|
|
|
|
return { enhanced: true, bonusMessage: level % 5 === 0 }; |
|
|
}); |
|
|
|
|
|
// Message de bonus de milestone |
|
|
game.crocojup('milestone_bonus', { |
|
|
text: 'BONUS MILESTONE !', |
|
|
duration: 4000, |
|
|
style: { color: 'rainbow', size: 'huge', effect: 'sparkle' }, |
|
|
animation: 'explosion' |
|
|
}, function(messageData, context) { |
|
|
const bonusReward = context.level * 10; |
|
|
|
|
|
// Ajouter des pièces bonus |
|
|
if (this.economy && this.economy.currencies.gold) { |
|
|
this.economy.currencies.gold.amount += bonusReward; |
|
|
} |
|
|
|
|
|
console.log(`💰 Bonus milestone: ${bonusReward} pièces d'or !`); |
|
|
|
|
|
return { coinsAwarded: bonusReward }; |
|
|
}); |
|
|
|
|
|
// Déclencher automatiquement lors des level ups |
|
|
game.on('levelUp', (data) => { |
|
|
game.showTemporaryMessage('levelup_celebration', { level: data.newLevel }); |
|
|
}); |
|
|
``` |
|
|
|
|
|
### `crocodae(powerUpId, powerUpData, powerUpLogic)` - Power-ups temporaires avancés |
|
|
|
|
|
Créez des power-ups temporaires avec des effets complexes. |
|
|
|
|
|
```javascript |
|
|
// Power-up "Temps Ralenti" qui affecte tout le jeu |
|
|
game.crocodae('bullet_time', { |
|
|
name: 'Temps Ralenti', |
|
|
duration: 8000, |
|
|
effects: { |
|
|
timeMultiplier: 0.5, |
|
|
playerSpeedBoost: 1.5, |
|
|
crocodileSlowDown: 0.3 |
|
|
}, |
|
|
cooldown: 20000, |
|
|
rarity: 'epic' |
|
|
}, function(powerUpData, context, action) { |
|
|
if (action === 'activate') { |
|
|
console.log('⏰ TEMPS RALENTI ACTIVÉ !'); |
|
|
|
|
|
// Ralentir tous les crocodiles |
|
|
if (this.crocodileSpeeds) { |
|
|
Object.keys(this.crocodileSpeeds).forEach(crocoId => { |
|
|
const croco = this.crocodileSpeeds[crocoId]; |
|
|
croco.originalSpeed = croco.currentSpeed; |
|
|
croco.currentSpeed *= powerUpData.effects.crocodileSlowDown; |
|
|
}); |
|
|
} |
|
|
|
|
|
// Effet visuel |
|
|
this.emit('bulletTimeStart', { |
|
|
timeMultiplier: powerUpData.effects.timeMultiplier, |
|
|
duration: powerUpData.duration |
|
|
}); |
|
|
|
|
|
// Son ralenti |
|
|
this.emit('playSound', { sound: 'bullet_time_start', pitch: 0.7 }); |
|
|
|
|
|
} else if (action === 'deactivate') { |
|
|
console.log('⏰ Temps normal rétabli.'); |
|
|
|
|
|
// Restaurer la vitesse normale des crocodiles |
|
|
if (this.crocodileSpeeds) { |
|
|
Object.keys(this.crocodileSpeeds).forEach(crocoId => { |
|
|
const croco = this.crocodileSpeeds[crocoId]; |
|
|
if (croco.originalSpeed) { |
|
|
croco.currentSpeed = croco.originalSpeed; |
|
|
delete croco.originalSpeed; |
|
|
} |
|
|
}); |
|
|
} |
|
|
|
|
|
this.emit('bulletTimeEnd'); |
|
|
} |
|
|
}); |
|
|
|
|
|
// Power-up "Berserker" qui augmente tout |
|
|
game.crocodae('berserker_mode', { |
|
|
name: 'Mode Berserker', |
|
|
duration: 12000, |
|
|
effects: { |
|
|
damageMultiplier: 3, |
|
|
speedBoost: 2, |
|
|
killsToWin: 0.5 // Divise par 2 le nombre de kills nécessaires |
|
|
}, |
|
|
stackable: false, |
|
|
cooldown: 30000 |
|
|
}, function(powerUpData, context, action) { |
|
|
if (action === 'activate') { |
|
|
console.log('🔥 MODE BERSERKER ACTIVÉ !'); |
|
|
|
|
|
// Stocker les valeurs originales |
|
|
this.originalSettings = { |
|
|
levelUpThreshold: this.settings.levelUpThreshold |
|
|
}; |
|
|
|
|
|
// Réduire le nombre de crocodiles nécessaires pour level up |
|
|
this.settings.levelUpThreshold = Math.ceil(this.settings.levelUpThreshold * powerUpData.effects.killsToWin); |
|
|
|
|
|
this.emit('berserkerModeStart', { |
|
|
effects: powerUpData.effects, |
|
|
visualEffect: 'red_aura' |
|
|
}); |
|
|
|
|
|
} else if (action === 'deactivate') { |
|
|
console.log('🔥 Mode Berserker terminé.'); |
|
|
|
|
|
// Restaurer les paramètres |
|
|
if (this.originalSettings) { |
|
|
this.settings.levelUpThreshold = this.originalSettings.levelUpThreshold; |
|
|
delete this.originalSettings; |
|
|
} |
|
|
|
|
|
this.emit('berserkerModeEnd'); |
|
|
} |
|
|
}); |
|
|
|
|
|
// Activer les power-ups selon certaines conditions |
|
|
game.on('crocoKilled', (data) => { |
|
|
if (data.killedCount % 10 === 0) { // Tous les 10 kills |
|
|
if (Math.random() < 0.3) { // 30% de chance |
|
|
game.activateTemporaryPowerUp('bullet_time'); |
|
|
} |
|
|
} |
|
|
|
|
|
if (this.armHealth < 30 && Math.random() < 0.2) { // 20% si vie critique |
|
|
game.activateTemporaryPowerUp('berserker_mode'); |
|
|
} |
|
|
}); |
|
|
``` |
|
|
|
|
|
### `crocolog(logId, logConfig, logLogic)` - Logs personnalisés créatifs |
|
|
|
|
|
Créez un système de logging avec des formes et des couleurs. |
|
|
|
|
|
```javascript |
|
|
// Système de log avec formes ASCII et couleurs |
|
|
game.crocolog('ascii_logger', { |
|
|
prefix: '🐊', |
|
|
colors: { |
|
|
info: '\x1b[36m', // Cyan |
|
|
warning: '\x1b[33m', // Jaune |
|
|
error: '\x1b[31m', // Rouge |
|
|
success: '\x1b[32m', // Vert |
|
|
reset: '\x1b[0m' // Reset |
|
|
}, |
|
|
shapes: { |
|
|
box: '█', |
|
|
triangle: '▲', |
|
|
diamond: '◆', |
|
|
star: '★', |
|
|
heart: '♥' |
|
|
}, |
|
|
format: 'creative' |
|
|
}, function(logConfig, logEntry) { |
|
|
const { colors, shapes, prefix } = logConfig; |
|
|
const { message, data, level, timestamp } = logEntry; |
|
|
|
|
|
// Créer un motif selon le niveau |
|
|
let pattern = ''; |
|
|
let color = colors[level] || colors.info; |
|
|
|
|
|
switch (level) { |
|
|
case 'success': |
|
|
pattern = shapes.star.repeat(3); |
|
|
break; |
|
|
case 'error': |
|
|
pattern = shapes.triangle.repeat(5); |
|
|
break; |
|
|
case 'warning': |
|
|
pattern = shapes.diamond.repeat(4); |
|
|
break; |
|
|
default: |
|
|
pattern = shapes.box.repeat(2); |
|
|
} |
|
|
|
|
|
// Format créatif avec timestamp |
|
|
const timeStr = new Date(timestamp).toLocaleTimeString(); |
|
|
const formattedMessage = `${color}${pattern} ${prefix} [${timeStr}] ${message} ${pattern}${colors.reset}`; |
|
|
|
|
|
// Ajouter des données supplémentaires si présentes |
|
|
if (data.shape) { |
|
|
const customShape = shapes[data.shape] || '?'; |
|
|
return formattedMessage + `\n${color}${customShape.repeat(10)}${colors.reset}`; |
|
|
} |
|
|
|
|
|
return formattedMessage; |
|
|
}); |
|
|
|
|
|
// Logger de combat avec statistiques visuelles |
|
|
game.crocolog('combat_stats', { |
|
|
prefix: '⚔️', |
|
|
format: 'stats', |
|
|
shapes: { |
|
|
health: '♥', |
|
|
kill: '💀', |
|
|
level: '⭐' |
|
|
} |
|
|
}, function(logConfig, logEntry) { |
|
|
const { message, data } = logEntry; |
|
|
const { shapes } = logConfig; |
|
|
|
|
|
if (data.type === 'combat_summary') { |
|
|
const healthBar = shapes.health.repeat(Math.floor(data.armHealth / 10)); |
|
|
const killCount = shapes.kill.repeat(Math.min(data.kills, 10)); |
|
|
const levelStars = shapes.level.repeat(data.level); |
|
|
|
|
|
return ` |
|
|
╔══════════════════════════════════╗ |
|
|
║ ${message.padEnd(32)} ║ |
|
|
║ Vie: ${healthBar.padEnd(20)} ║ |
|
|
║ Kills: ${killCount.padEnd(18)} ║ |
|
|
║ Niveau: ${levelStars.padEnd(15)} ║ |
|
|
╚══════════════════════════════════╝`; |
|
|
} |
|
|
|
|
|
return `⚔️ ${message}`; |
|
|
}); |
|
|
|
|
|
// Utiliser les logs personnalisés |
|
|
game.writeCustomLog('ascii_logger', 'Crocodile éliminé !', { level: 'success', shape: 'star' }); |
|
|
game.writeCustomLog('ascii_logger', 'Attention, bras en danger !', { level: 'warning' }); |
|
|
|
|
|
// Log automatique des statistiques de combat |
|
|
game.on('levelUp', (data) => { |
|
|
game.writeCustomLog('combat_stats', 'NIVEAU SUPÉRIEUR !', { |
|
|
type: 'combat_summary', |
|
|
armHealth: game.armHealth, |
|
|
kills: game.killedCrocodilesThisLevel, |
|
|
level: data.newLevel |
|
|
}); |
|
|
}); |
|
|
``` |
|
|
|
|
|
### `crocojust(cloneId, cloneData, cloneLogic)` - Clonage et invocation de crocodiles |
|
|
|
|
|
Permettez aux crocodiles de se dupliquer ou d'invoquer des alliés. |
|
|
|
|
|
```javascript |
|
|
// Système de clonage pour crocodiles alpha |
|
|
game.crocojust('alpha_cloning', { |
|
|
maxClones: 2, |
|
|
cloneCooldown: 8000, |
|
|
cloneConditions: { minLevel: 3, healthThreshold: 0.5 }, |
|
|
cloneProperties: { health: 0.7, speed: 1.2, lifespan: 15000 }, |
|
|
invocationRules: { maxInvocations: 3 } |
|
|
}, function(cloneData, context) { |
|
|
const { sourceCrocoId, gameState, context: cloneContext } = context; |
|
|
|
|
|
// Vérifier si les conditions de clonage sont remplies |
|
|
const canClone = gameState.currentLevel >= cloneData.cloneConditions.minLevel; |
|
|
const sourceHealth = this.crocodileHealths && this.crocodileHealths[sourceCrocoId] ? |
|
|
this.crocodileHealths[sourceCrocoId].currentHealth : 100; |
|
|
const healthOk = sourceHealth >= 50; // Santé minimale pour cloner |
|
|
|
|
|
if (canClone && healthOk && Math.random() < 0.3) { // 30% de chance |
|
|
const cloneId = Date.now() + Math.random(); |
|
|
|
|
|
// Créer le clone avec propriétés réduites |
|
|
this.crocolife(cloneId, Math.floor(sourceHealth * cloneData.cloneProperties.health)); |
|
|
this.crocorap(cloneId, 1.0 * cloneData.cloneProperties.speed); |
|
|
|
|
|
console.log(`🧬 Crocodile ${sourceCrocoId} se clone ! Clone ID: ${cloneId}`); |
|
|
|
|
|
// Le clone disparaît automatiquement après un délai |
|
|
setTimeout(() => { |
|
|
if (this.crocodileHealths && this.crocodileHealths[cloneId]) { |
|
|
delete this.crocodileHealths[cloneId]; |
|
|
this.emit('cloneExpired', { cloneId, sourceId: sourceCrocoId }); |
|
|
console.log(`💨 Clone ${cloneId} disparaît.`); |
|
|
} |
|
|
}, cloneData.cloneProperties.lifespan); |
|
|
|
|
|
return { |
|
|
success: true, |
|
|
cloneId: cloneId, |
|
|
properties: { |
|
|
health: Math.floor(sourceHealth * cloneData.cloneProperties.health), |
|
|
speed: cloneData.cloneProperties.speed, |
|
|
temporary: true |
|
|
} |
|
|
}; |
|
|
} |
|
|
|
|
|
return { success: false, reason: 'Conditions non remplies' }; |
|
|
}); |
|
|
|
|
|
// Invocation de crocodiles minions |
|
|
game.crocojust('necro_summoning', { |
|
|
maxClones: 5, |
|
|
cloneCooldown: 12000, |
|
|
invocationRules: { |
|
|
minionType: 'skeleton_croco', |
|
|
minionHealth: 30, |
|
|
minionCount: 3 |
|
|
} |
|
|
}, function(cloneData, context) { |
|
|
const { sourceCrocoId } = context; |
|
|
const summonedMinions = []; |
|
|
|
|
|
console.log(`🧙♂️ Crocodile nécromancien ${sourceCrocoId} invoque des squelettes !`); |
|
|
|
|
|
for (let i = 0; i < cloneData.invocationRules.minionCount; i++) { |
|
|
const minionId = Date.now() + i; |
|
|
|
|
|
// Créer un minion squelette |
|
|
this.crocolife(minionId, cloneData.invocationRules.minionHealth); |
|
|
this.crocoarmure(minionId, 10); // Fragile |
|
|
this.crocorap(minionId, 0.8); // Lent |
|
|
|
|
|
// Comportement spécial des minions |
|
|
this.crocia(minionId, 'minion', (aiData) => { |
|
|
return { action: 'swarm_attack', newState: 'swarming' }; |
|
|
}); |
|
|
|
|
|
summonedMinions.push(minionId); |
|
|
} |
|
|
|
|
|
return { |
|
|
success: true, |
|
|
cloneId: 'multiple', |
|
|
summonedMinions: summonedMinions, |
|
|
properties: { type: 'necromancy', count: summonedMinions.length } |
|
|
}; |
|
|
}); |
|
|
|
|
|
// Déclencher le clonage automatiquement |
|
|
game.on('crocoKilled', (data) => { |
|
|
// Chance de clonage pour les crocodiles survivants |
|
|
if (Math.random() < 0.15) { // 15% de chance |
|
|
game.cloneCrocodile('alpha_cloning', 1); |
|
|
} |
|
|
|
|
|
// Invocation nécromantique si beaucoup de crocodiles morts |
|
|
if (data.killedCount > 10 && data.killedCount % 7 === 0) { |
|
|
game.cloneCrocodile('necro_summoning', 666); // ID du nécromancien |
|
|
} |
|
|
}); |
|
|
``` |
|
|
|
|
|
### Et 6 autres fonctionnalités innovantes... |
|
|
|
|
|
Les fonctionnalités restantes (`crocorare`, `crocomd`, `crocoglop`, `crocofarm`, `crocenvie`) offrent des possibilités infinies pour créer des expériences de jeu uniques avec des crocodiles rares, des tutoriels interactifs, des personnalisations comportementales, des systèmes de reproduction et des motivations complexes pour vos crocodiles. |
|
|
|
|
|
## Événements v1.3.0 |
|
|
|
|
|
Les nouvelles fonctionnalités émettent de nombreux nouveaux événements : |
|
|
|
|
|
```javascript |
|
|
// Événements des quêtes dynamiques |
|
|
game.on('dynamicQuestStarted', (data) => { |
|
|
console.log(`Quête dynamique ${data.questId} démarrée !`); |
|
|
}); |
|
|
|
|
|
// Événements climatiques |
|
|
game.on('weatherActivated', (data) => { |
|
|
console.log(`Climat ${data.weatherId} activé !`); |
|
|
}); |
|
|
|
|
|
// Événements IA avancée |
|
|
game.on('advancedAIDecision', (data) => { |
|
|
console.log(`IA ${data.crocoId}: ${JSON.stringify(data.decision)}`); |
|
|
}); |
|
|
|
|
|
// Et plus de 50 nouveaux événements... |
|
|
``` |
|
|
|
|
|
## Exemple complet v1.3.0 |
|
|
|
|
|
```javascript |
|
|
const CrocobrasGame = require('crocobras'); |
|
|
const game = new CrocobrasGame(); |
|
|
|
|
|
// Configuration complète avec les nouvelles fonctionnalités |
|
|
function setupAdvancedGame() { |
|
|
// 1. Quête adaptative |
|
|
game.crocojom('main_quest', { |
|
|
title: 'La Grande Chasse', |
|
|
branches: { start: { choices: ['brave', 'careful'] } } |
|
|
}, (questData, progress, action, choice) => { |
|
|
if (choice?.action === 'brave') { |
|
|
game.activateWeather('storm'); |
|
|
} |
|
|
}); |
|
|
|
|
|
// 2. Climat dynamique |
|
|
game.crocera('fog', { |
|
|
duration: 20000, |
|
|
crocodileEffects: { stealth: 1.5 } |
|
|
}, (weatherData) => { |
|
|
console.log('🌫️ Brouillard épais !'); |
|
|
}); |
|
|
|
|
|
// 3. IA avancée |
|
|
game.crocorin(1, { learningRate: 0.2 }, (aiData) => { |
|
|
return { action: 'adaptive_hunt', confidence: 0.8 }; |
|
|
}); |
|
|
|
|
|
// 4. Messages temporaires |
|
|
game.crocojup('achievement', { |
|
|
text: 'SUCCÈS DÉBLOQUÉ !', |
|
|
duration: 2000 |
|
|
}, (data) => ({ enhanced: true })); |
|
|
|
|
|
// 5. Logs créatifs |
|
|
game.crocolog('game_logger', { |
|
|
colors: { info: '\x1b[36m' }, |
|
|
shapes: { star: '★' } |
|
|
}, (config, entry) => { |
|
|
return `${config.colors.info}★ ${entry.message} ★\x1b[0m`; |
|
|
}); |
|
|
} |
|
|
|
|
|
setupAdvancedGame(); |
|
|
game.startGame(); |
|
|
|
|
|
// Démarrer une quête dynamique |
|
|
game.startDynamicQuest('main_quest'); |
|
|
|
|
|
console.log('🚀 Jeu Crocobras v1.3.0 avec toutes les fonctionnalités avancées !'); |
|
|
``` |
|
|
|
|
|
## Contribution |
|
|
|
|
|
Toutes les idées et contributions sont les bienvenues ! N'hésitez pas à ouvrir des issues ou à soumettre des pull requests sur le dépôt GitHub. |
|
|
|
|
|
## Changelog v1.3.0 |
|
|
|
|
|
- ✨ Ajout de `crocojom()` pour les quêtes dynamiques adaptatives |
|
|
- ✨ Ajout de `crocera()` pour le système climatique interactif |
|
|
- ✨ Ajout de `crocogiw()` pour les événements spéciaux conditionnels |
|
|
- ✨ Ajout de `crocorin()` pour l'IA avancée avec prise de décision |
|
|
- ✨ Ajout de `crocomp()` pour l'analyse de données de jeu |
|
|
- ✨ Ajout de `crocotina()` pour les fonctions JavaScript personnalisées |
|
|
- ✨ Ajout de `crocofaf()` pour les mini-jeux de quiz créatifs |
|
|
- ✨ Ajout de `crocojup()` pour les messages temporaires personnalisés |
|
|
- ✨ Ajout de `crocodae()` pour les power-ups temporaires avançés |
|
|
- ✨ Ajout de `crocolog()` pour les logs personnalisés créatifs |
|
|
- ✨ Ajout de `crocojust()` pour le clonage et l'invocation de crocodiles |
|
|
- ✨ Ajout de `crocorare()` pour les crocodiles rares spéciaux |
|
|
- ✨ Ajout de `crocomd()` pour les tutoriels interactifs |
|
|
- ✨ Ajout de `crocoglop()` pour la personnalisation comportementale |
|
|
- ✨ Ajout de `crocofarm()` pour le système de bébés crocodiles |
|
|
- ✨ Ajout de `crocenvie()` pour le système d'envies des crocodiles |
|
|
- 📡 Plus de 50 nouveaux événements pour toutes les nouvelles fonctionnalités |
|
|
- 🎮 Possibilités créatives infinies pour les développeurs |
|
|
- 🧠 IA et systèmes adaptatifs révolutionnaires |
|
|
- 🌟 Gameplay dynamique et évolutif |
|
|
|
|
|
**Lien de notre documentation officielle** : |
|
|
|
|
|
https://croco-combat-arena.lovable.app/ |
|
|
|
|
|
|
|
|
|
