rework task rewards

src/app/app.component.html

@@ -124,7 +124,7 @@
         </div>
         <div class="container-sider-title">{{getSiderTitle()}}</div>
         <div class="container-sider-elements">
-            <app-rewards class="container-sider-elements-element" [task]="pieceDetailsService.pieceAsTask()" [role]="pieceDetailsService.parentAsRole()" *ngIf="pieceDetailsService.pieceIsTask()" [scenario]="scenario"></app-rewards>
+            <app-rewards class="container-sider-elements-element" [task]="pieceDetailsService.pieceAsTask()" [role]="pieceDetailsService.parentAsRole()" *ngIf="pieceDetailsService.pieceIsTask() && !unityService.unity_isActive" [scenario]="scenario"></app-rewards>
             <app-role-occurence class="container-sider-elements-element" [role]="pieceDetailsService.pieceAsRole()" *ngIf="pieceDetailsService.pieceIsRole()" [scenario]="scenario"></app-role-occurence>
             <app-supplementary-task class="container-sider-elements-element" [task]="pieceDetailsService.pieceAsTask()" [role]="pieceDetailsService.parentAsRole()" *ngIf="pieceDetailsService.pieceIsTask()" [scenario]="scenario"></app-supplementary-task>
             <app-repeat class="container-sider-elements-element" [task]="pieceDetailsService.pieceAsTask()" *ngIf="pieceDetailsService.pieceIsTask()" [scenario]="scenario"></app-repeat>

src/app/app.component.ts

@@ -47,6 +47,7 @@ import { Response } from './class/response/response';
 import { Sentence } from './class/sentence/sentence';
 import { InterrogativeSentence } from './class/sentence/interrogativeSentence/interrogative-sentence';
 import { DeclarativeSentence } from './class/sentence/declarativeSentence/declarative-sentence';
+import { ObjectReward } from './class/rewards/object-reward/object-reward';
 
 @Component({
   selector: 'app-root',
@@ -349,20 +350,45 @@ export class AppComponent {
                         prerequire.ressource = role.ressources[i];
                       }
                     })
-                    if (task.rewardType == 'object' || task.rewardType == 'skill') {
-                      if (scenario.ressources.some(element => element.name == (task.reward as Ressource).name && element.type == (task.reward as Ressource).type && element.number == (task.reward as Ressource).number)) {
-                        let i: number = scenario.ressources.findIndex(element => element.name == (task.reward as Ressource).name && element.type == (task.reward as Ressource).type && element.number == (task.reward as Ressource).number);
-                        task.reward = scenario.ressources[i];
-                      } else {
-                        let i: number = role.ressources.findIndex(element => element.name == (task.reward as Ressource).name && element.type == (task.reward as Ressource).type && element.number == (task.reward as Ressource).number);
-                        task.reward = role.ressources[i];
-                      }
-                    } else if (task.rewardType == 'character') {
-                      let i: number = scenario.characters.findIndex(element => element.name == (task.reward as Character).name && element.description == (task.reward as Character).description && element.color == (task.reward as Character).color);
-                      task.reward = scenario.characters[i];
-                    }
-
 
+                    task.rewards.forEach((reward, rewardIndex) => {
+                      if (reward.type == 'object') {
+                        if (scenario.ressources.some(element => element.name == (reward as ObjectReward).object.name && element.type == (reward as ObjectReward).object.type && element.number == (reward as ObjectReward).object.number)) {
+                          let i: number = scenario.ressources.findIndex(element => element.name == (reward as ObjectReward).object.name && element.type == (reward as ObjectReward).object.type && element.number == (reward as ObjectReward).object.number);
+                          let newReward: ObjectReward = new ObjectReward();
+                          newReward.object = scenario.ressources[i];
+                          newReward.quantity = (reward as ObjectReward).quantity;
+                          task.rewards[rewardIndex] = newReward;
+                        } else {
+                          let i: number = role.ressources.findIndex(element => element.name == (reward as ObjectReward).object.name && element.type == (reward as ObjectReward).object.type && element.number == (reward as ObjectReward).object.number);
+                          let newReward: ObjectReward = new ObjectReward();
+                          newReward.object = role.ressources[i];
+                          newReward.quantity = (reward as ObjectReward).quantity;
+                          task.rewards[rewardIndex] = newReward;
+                        }
+                      }
+                      if (reward.type == 'skill') {
+                        if (scenario.ressources.some(element => element.name == (reward as SkillReward).skill.name && element.type == (reward as SkillReward).skill.type && element.number == (reward as SkillReward).skill.number)) {
+                          let i: number = scenario.ressources.findIndex(element => element.name == (reward as SkillReward).skill.name && element.type == (reward as SkillReward).skill.type && element.number == (reward as SkillReward).skill.number);
+                          let newReward: SkillReward = new SkillReward();
+                          newReward.skill = scenario.ressources[i];
+                          newReward.quantity = (reward as SkillReward).quantity;
+                          task.rewards[rewardIndex] = newReward;
+                        } else {
+                          let i: number = role.ressources.findIndex(element => element.name == (reward as SkillReward).skill.name && element.type == (reward as SkillReward).skill.type && element.number == (reward as SkillReward).skill.number);
+                          let newReward: SkillReward = new SkillReward();
+                          newReward.skill = role.ressources[i];
+                          newReward.quantity = (reward as SkillReward).quantity;
+                          task.rewards[rewardIndex] = newReward;
+                        }
+                      }
+                      if (reward.type == 'character') {
+                        let i: number = scenario.characters.findIndex(element => element.name == (reward as CharacterReward).character.name && element.description == (reward as CharacterReward).character.description && element.color == (reward as CharacterReward).character.color);
+                        let newReward: CharacterReward = new CharacterReward();
+                        newReward.character = scenario.characters[i];
+                        task.rewards[rewardIndex] = newReward;
+                      }
+                    });
                     if ((task.typeUnity == 'getObject' || task.typeUnity == 'depositObject' || task.typeUnity == 'interactObject') && task.object) {
                       if (scenario.ressources.some(element => element.name == (task.object as Ressource).name && element.number == (task.object as Ressource).number && element.type == (task.object as Ressource).type)) {
                         let i: number = scenario.ressources.findIndex(element => element.name == (task.object as Ressource).name && element.number == (task.object as Ressource).number && element.type == (task.object as Ressource).type);

src/app/class/rewards/object-reward/object-reward.spec.ts

+import { ObjectReward } from './object-reward';
+
+describe('ObjectReward', () => {
+  it('should create an instance', () => {
+    expect(new ObjectReward()).toBeTruthy();
+  });
+});

src/app/class/rewards/object-reward/object-reward.ts

+import { Ressource } from "../../ressource/ressource";
+import { Reward } from "../reward";
+
+export class ObjectReward extends Reward{
+
+    constructor() {
+        super('object');
+    }
+
+    quantity: number = 1;
+    object: Ressource = new Ressource();
+}

src/app/class/task/task.ts

@@ -4,6 +4,7 @@ import { PrerequireRessource } from "../prerequires/prerequire-ressource/prerequ
 import { PrerequireTask } from "../prerequires/prerequire-task/prerequire-task";
 import { Repeat } from "../repeat/repeat";
 import { Ressource } from "../ressource/ressource";
+import { Reward } from "../rewards/reward";
 import { SupplementaryRole } from "../supplementary-role/supplementary-role";
 import { Symbol } from "../symbol/symbol";
 
@@ -36,10 +37,7 @@ export class Task {
     supplementaryRole!: SupplementaryRole;
     interrupt: string = '';
 
-    rewardType: string = 'none'; //none / object / character / skill
-    //rewardName: string = '';
-    rewardQuantity: number = 1;
-    reward: (Character | Ressource | null) = null;
+    rewards: Reward[] = [];
 
     constructor(type: string) {
         this.type = type;
@@ -54,12 +52,7 @@ export class Task {
             this.type = type;
         }
     }
-
-    public resetReward(): void {
-        this.reward = null;
-        this.rewardQuantity = 1;
-    }
-
+ 
     public resetUnityContent(): void {
         this.object = null;
         this.objectQuantity = 1;

src/app/pieces/game-characters/game-characters.component.ts

@@ -11,6 +11,7 @@ import { Trace } from 'src/app/class/trace/trace';
 import { MinimapService } from 'src/app/services/minimap/minimap.service';
 import { TranslateService } from '@ngx-translate/core';
 import { UnityService } from 'src/app/services/unity/unity.service';
+import { CharacterReward } from 'src/app/class/rewards/character-reward/character-reward';
 
 @Component({
   selector: 'app-game-characters',
@@ -47,14 +48,16 @@ export class GameCharactersComponent implements OnInit {
             role.tasks.forEach(inlineTasks => {
               inlineTasks.forEach(task => {
                 if (task instanceof Task) {
-                  task.characters = [];
-                  if (task.rewardType == 'character') {
-                    task.resetReward();
-                    task.rewardType = 'none';
-                  }
+                  for (let i = 0; i < task.rewards.length; i++) {
+                    let reward = task.rewards[i];
+                    if (reward.type == 'character') {
+                      task.rewards.splice(i,1);
+                      i--;
+                    }
+                  }    
                   if (task?.typeUnity == 'character' || task?.typeUnity == 'exchangeObjects') {
                     task.character = null;
-                  }
+                  }                                
                 }
               });
             });
@@ -85,16 +88,22 @@ export class GameCharactersComponent implements OnInit {
             mission.roles.forEach(role => {
               role.tasks.forEach(inlineTask => {
                 inlineTask.forEach(task => {
-                  let i: number | undefined = task?.characters.findIndex(character => character == this.scenario.characters[index]);
-                  if (typeof i !== 'undefined' && i !== -1) {
-                    task?.characters.splice(i, 1);
-                  }
-                  if (task?.rewardType == 'character' && task.reward == this.scenario.characters[index]) {
-                    task.resetReward();
-                    task.rewardType = 'none';
-                  }
-                  if ((task?.typeUnity == 'character' || task?.typeUnity == 'exchangeObjects') && task.character == this.scenario.characters[index]) {
-                    task.character = null;
+                  if (task instanceof Task) {
+                    let i: number | undefined = task?.characters.findIndex(character => character == this.scenario.characters[index]);
+                    if (typeof i !== 'undefined' && i !== -1) {
+                      task?.characters.splice(i, 1);
+                    }
+                    for (let rewardIndex = 0; rewardIndex < task.rewards.length; rewardIndex++) {
+                      let reward = task.rewards[rewardIndex];
+                      if (reward.type == 'character') {
+                        if ((reward as CharacterReward).character == this.scenario.characters[index])
+                        task.rewards.splice(rewardIndex,1);
+                        rewardIndex--;
+                      }
+                    }    
+                    if ((task?.typeUnity == 'character' || task?.typeUnity == 'exchangeObjects') && task.character == this.scenario.characters[index]) {
+                      task.character = null;
+                    }                    
                   }
                 });
               });

src/app/pieces/role/role.component.ts

@@ -27,6 +27,7 @@ import { CopyRoleService } from 'src/app/services/copyRole/copy-role.service';
 import { Task } from 'src/app/class/task/task';
 import { CopyRoleSuccessComponent } from 'src/app/components/snackbars/copy-role-success/copy-role-success.component';
 import { RoleOccurrence } from 'src/app/class/role-occurrence/role-occurrence';
+import { ObjectReward } from 'src/app/class/rewards/object-reward/object-reward';
 
 @Component({
   selector: 'app-role',
@@ -197,34 +198,47 @@ export class RoleComponent implements OnInit {
         this.role.tasks.forEach(inlineTasks => {
           inlineTasks.forEach(task => {
             this.role.ressources.forEach(ressource => {
-              if (task?.prerequireRessources.some(element => element.ressource == ressource)) {
-                let index: number = task.prerequireRessources.findIndex(element => element.ressource == ressource);
-                task.prerequireRessources.splice(index, 1);
-              }
-              if ((task?.rewardType == 'object' || task?.rewardType == 'attribut') && task.reward == ressource) {
-                task.resetReward();
-                task.rewardType = 'none';
-              }
-              if (task?.typeUnity == 'getObject' || task?.typeUnity == 'combineObjects' || task?.typeUnity == 'exchangeObjects' || task?.typeUnity == 'depositObject' || task?.typeUnity == 'interactObject') {
-                if (task.object == ressource) {
-                  task.object = null;
+              if (task instanceof Task) {
+                if (task?.prerequireRessources.some(element => element.ressource == ressource)) {
+                  let index: number = task.prerequireRessources.findIndex(element => element.ressource == ressource);
+                  task.prerequireRessources.splice(index, 1);
                 }
-                task.combineObjects.forEach((object, i) => {
-                  if (object[0] == ressource) {
-                    task.combineObjects[i][0] = null;
+                for (let i = 0; i < task?.rewards.length; i++) {
+                  let reward = task.rewards[i];
+                  if (reward.type == 'object') {
+                    if ((reward as ObjectReward).object == ressource) {
+                      task.rewards.splice(i,1);
+                      i--;
+                    }
                   }
-                });
-                task.giveObjects.forEach((object, i) => {
-                  if (object[0] == ressource) {
-                    task.giveObjects[i][0] = null;
+                  if (reward.type == 'skill') {
+                    if ((reward as SkillReward).skill == ressource) {
+                      task.rewards.splice(i,1);
+                      i--;
+                    }
                   }
-                });
-                task.receiveObjects.forEach((object, i) => {
-                  if (object[0] == ressource) {
-                    task.receiveObjects[i][0] = null;
+                }
+                if (task?.typeUnity == 'getObject' || task?.typeUnity == 'combineObjects' || task?.typeUnity == 'exchangeObjects' || task?.typeUnity == 'depositObject' || task?.typeUnity == 'interactObject') {
+                  if (task.object == ressource) {
+                    task.object = null;
                   }
-                });
-              }
+                  task.combineObjects.forEach((object, i) => {
+                    if (object[0] == ressource) {
+                      task.combineObjects[i][0] = null;
+                    }
+                  });
+                  task.giveObjects.forEach((object, i) => {
+                    if (object[0] == ressource) {
+                      task.giveObjects[i][0] = null;
+                    }
+                  });
+                  task.receiveObjects.forEach((object, i) => {
+                    if (object[0] == ressource) {
+                      task.receiveObjects[i][0] = null;
+                    }
+                  });
+                }
+              }      
             });
           });
         });
@@ -303,35 +317,48 @@ export class RoleComponent implements OnInit {
       if (result == true) {
         this.role.tasks.forEach(inlineTasks => {
           inlineTasks.forEach(task => {
-            task?.prerequireRessources.forEach((prerequire, j) => {
-              if (prerequire.ressource == this.role.ressources[index]) {
-                task.prerequireRessources.splice(j, 1);
-              }
-            });
-            if ((task?.rewardType == 'object' || task?.rewardType == 'skill') && task.reward == this.role.ressources[index]) {
-              task.resetReward();
-              task.rewardType = 'none';
-            }
-            if (task?.typeUnity == 'getObject' || task?.typeUnity == 'combineObjects' || task?.typeUnity == 'exchangeObjects' || task?.typeUnity == 'depositObject' || task?.typeUnity == 'interactObject') {
-              if (task.object == this.role.ressources[index]) {
-                task.object = null;
-              }
-              task.combineObjects.forEach((object, i) => {
-                if (object[0] == this.role.ressources[index]) {
-                  task.combineObjects[i][0] = null;
+            if (task instanceof Task) {
+              task?.prerequireRessources.forEach((prerequire, j) => {
+                if (prerequire.ressource == this.role.ressources[index]) {
+                  task.prerequireRessources.splice(j, 1);
                 }
               });
-              task.giveObjects.forEach((object, i) => {
-                if (object[0] == this.role.ressources[index]) {
-                  task.giveObjects[i][0] = null;
+              for (let i = 0; i < task?.rewards.length; i++) {
+                let reward = task.rewards[i];
+                if (reward.type == 'object') {
+                  if ((reward as ObjectReward).object == this.role.ressources[index]) {
+                    task.rewards.splice(i,1);
+                    i--;
+                  }
                 }
-              });
-              task.receiveObjects.forEach((object, i) => {
-                if (object[0] == this.role.ressources[index]) {
-                  task.receiveObjects[i][0] = null;
+                if (reward.type == 'skill') {
+                  if ((reward as SkillReward).skill == this.role.ressources[index]) {
+                    task.rewards.splice(i,1);
+                    i--;
+                  }
                 }
-              });
-            }
+              }
+              if (task?.typeUnity == 'getObject' || task?.typeUnity == 'combineObjects' || task?.typeUnity == 'exchangeObjects' || task?.typeUnity == 'depositObject' || task?.typeUnity == 'interactObject') {
+                if (task.object == this.role.ressources[index]) {
+                  task.object = null;
+                }
+                task.combineObjects.forEach((object, i) => {
+                  if (object[0] == this.role.ressources[index]) {
+                    task.combineObjects[i][0] = null;
+                  }
+                });
+                task.giveObjects.forEach((object, i) => {
+                  if (object[0] == this.role.ressources[index]) {
+                    task.giveObjects[i][0] = null;
+                  }
+                });
+                task.receiveObjects.forEach((object, i) => {
+                  if (object[0] == this.role.ressources[index]) {
+                    task.receiveObjects[i][0] = null;
+                  }
+                });
+              }    
+            }       
           });
         });
         this.role.ressources.splice(index, 1);

src/app/pieces/rules/rules.component.ts

@@ -10,6 +10,7 @@ import { Task } from 'src/app/class/task/task';
 import { Trace } from 'src/app/class/trace/trace';
 import { MinimapService } from 'src/app/services/minimap/minimap.service';
 import { TranslateService } from '@ngx-translate/core';
+import { ObjectReward } from 'src/app/class/rewards/object-reward/object-reward';
 
 @Component({
   selector: 'app-rules',
@@ -49,9 +50,14 @@ export class RulesComponent implements OnInit {
                         task.prerequireRessources.splice(j, 1);
                       }
                     });
-                    if (task.rewardType == 'object' && ressource == task.reward) {
-                      task.resetReward();
-                      task.rewardType = 'none';
+                    for (let i = 0; i < task.rewards.length; i++) {
+                      let reward = task.rewards[i];
+                      if (reward.type == 'object') {
+                        if ((reward as ObjectReward).object == ressource) {
+                          task.rewards.splice(i,1);
+                          i--;                        
+                        }
+                      }
                     }
                     if (task?.typeUnity == 'getObject' || task?.typeUnity == 'combineObjects' || task?.typeUnity == 'exchangeObjects' || task?.typeUnity == 'depositObject' || task?.typeUnity == 'interactObject') {
                       if (task.object == ressource) {
@@ -102,35 +108,42 @@ export class RulesComponent implements OnInit {
           mission.roles.forEach(role => {
             role.tasks.forEach(inlineTasks => {
               inlineTasks.forEach(task => {
-                task?.prerequireRessources.forEach((prerequire, j) => {
-                  if (this.scenario.ressources[index] == prerequire.ressource) {
-                    task.prerequireRessources.splice(j, 1);
-                  }
-                });
-                if (task?.rewardType == 'object' && this.scenario.ressources[index] == task.reward) {
-                  task.resetReward();
-                  task.rewardType = 'none';
-                }
-                if (task?.typeUnity == 'getObject' || task?.typeUnity == 'combineObjects' || task?.typeUnity == 'exchangeObjects' || task?.typeUnity == 'depositObject' || task?.typeUnity == 'interactObject') {
-                  if (task.object == this.scenario.ressources[index]) {
-                    task.object = null;
-                  }
-                  task.combineObjects.forEach((object, i) => {
-                    if (object[0] == this.scenario.ressources[index]) {
-                      task.combineObjects[i][0] = null;
+                if (task instanceof Task) {
+                  task?.prerequireRessources.forEach((prerequire, j) => {
+                    if (this.scenario.ressources[index] == prerequire.ressource) {
+                      task.prerequireRessources.splice(j, 1);
                     }
                   });
-                  task.giveObjects.forEach((object, i) => {
-                    if (object[0] == this.scenario.ressources[index]) {
-                      task.giveObjects[i][0] = null;
+                  for (let i = 0; i < task.rewards.length; i++) {
+                    let reward = task.rewards[i];
+                    if (reward.type == 'object') {
+                      if ((reward as ObjectReward).object == this.scenario.ressources[index]) {
+                        task.rewards.splice(i,1);
+                        i--;                        
+                      }
                     }
-                  });
-                  task.receiveObjects.forEach((object, i) => {
-                    if (object[0] == this.scenario.ressources[index]) {
-                      task.receiveObjects[i][0] = null;
+                  }    
+                  if (task?.typeUnity == 'getObject' || task?.typeUnity == 'combineObjects' || task?.typeUnity == 'exchangeObjects' || task?.typeUnity == 'depositObject' || task?.typeUnity == 'interactObject') {
+                    if (task.object == this.scenario.ressources[index]) {
+                      task.object = null;
                     }
-                  });
-                }
+                    task.combineObjects.forEach((object, i) => {
+                      if (object[0] == this.scenario.ressources[index]) {
+                        task.combineObjects[i][0] = null;
+                      }
+                    });
+                    task.giveObjects.forEach((object, i) => {
+                      if (object[0] == this.scenario.ressources[index]) {
+                        task.giveObjects[i][0] = null;
+                      }
+                    });
+                    task.receiveObjects.forEach((object, i) => {
+                      if (object[0] == this.scenario.ressources[index]) {
+                        task.receiveObjects[i][0] = null;
+                      }
+                    });
+                  }
+                }      
               });
             });
           });

src/app/sider-pieces/rewards/rewards.component.html

@@ -3,26 +3,26 @@
 matTooltipPosition="before" [matTooltipDisabled]="!tooltipService.activatedTooltips">
     <div class="piece-form">
         <div class="piece-form-title">{{'rewards_title' | translate}}</div>
-        <div class="piece-form-content">
+        <div class="piece-form-content" *ngFor="let reward of task.rewards, let rewardIndex = index">          
             <div class="piece-form-content-type">
                 <label for="type">{{'rewards_type_label'| translate}}</label>
-                <select name="type" [(ngModel)]="task.rewardType" (change)="resetReward($event)">
-                    <option value="none" selected>{{'rewards_type_none' | translate}}</option>
+                <select name="type" [(ngModel)]="reward.type" (change)="changeRewardType(rewardIndex,reward.type)">
+                    <!--<option value="none" selected>{{'rewards_type_none' | translate}}</option>-->
                     <option value="object">{{'rewards_type_object' | translate}}</option>
                     <option value="character">{{'rewards_type_character' | translate}}</option>
                     <option value="skill">{{'rewards_type_skill' | translate}}</option>
                 </select>
             </div>
-            <div *ngIf="task.rewardType != 'none'">
+            <div *ngIf="reward.type != 'none'">
                 <!--
                 <div class="piece-form-content-name">
                     <label for="name">{{'rewards_name_label' | translate}}</label>
                     <input type="text" name="name" [(ngModel)]="task.rewardName">
                 </div>
-                -->
-                <div class="piece-form-content-object" *ngIf="task.rewardType == 'object'">
-                    <input type="number" name="quantity" [(ngModel)]="task.rewardQuantity"/>
-                    <select name="object_name" [(ngModel)]="task.reward" (change)="editTrace($event,'task_reward')">
+                -->     
+                <div class="piece-form-content-object" *ngIf="reward.type == 'object'">
+                    <input type="number" name="quantity" [(ngModel)]="getObjectReward(rewardIndex).quantity"/>
+                    <select name="object_name" [(ngModel)]="getObjectReward(rewardIndex).object">
                         <option value="null" selected disabled>{{'rewards_object_placeholder' | translate}}</option>
                         <ng-container *ngFor="let ressource of scenario.ressources">
                             <option *ngIf="ressource.type == 'ressource'" [ngValue]="ressource">{{ressource.name}}</option>
@@ -32,15 +32,15 @@ matTooltipPosition="before" [matTooltipDisabled]="!tooltipService.activatedToolt
                         </ng-container>
                     </select>
                 </div>
-                <div class="piece-form-content-character" *ngIf="task.rewardType == 'character'">
-                    <select name="character" [(ngModel)]="task.reward" (change)="editTrace($event,'task_reward')">
+                <div class="piece-form-content-character" *ngIf="reward.type == 'character'">
+                    <select name="character" [(ngModel)]="getCharacterReward(rewardIndex).character">
                         <option value="null" selected disabled>{{'rewards_character_placeholder' | translate}}</option>
                         <option *ngFor="let character of scenario.characters" [ngValue]="character">{{character.name}}</option>
                     </select>
                 </div>
-                <div class="piece-form-content-skill" *ngIf="task.rewardType == 'skill'">
-                    <input type="number" name="quantity" [(ngModel)]="task.rewardQuantity"/>
-                    <select name="skill" [(ngModel)]="task.reward" (change)="editTrace($event,'task_reward')">
+                <div class="piece-form-content-skill" *ngIf="reward.type == 'skill'">
+                    <input type="number" name="quantity" [(ngModel)]="getSkillReward(rewardIndex).quantity"/>
+                    <select name="skill" [(ngModel)]="getSkillReward(rewardIndex).skill">
                         <option value="null" selected disabled>{{'rewards_skill_placeholder' | translate}}</option>
                         <ng-container *ngFor="let ressource of pieceDetailsService.parentAsRole().ressources">
                             <option *ngIf="ressource.type == 'attribut'" [ngValue]="ressource">{{ressource.name}}</option>
@@ -48,6 +48,8 @@ matTooltipPosition="before" [matTooltipDisabled]="!tooltipService.activatedToolt
                     </select>
                 </div>
             </div>
+            <button mat-button class="piece-form-buttons-remove" (click)="removeReward(rewardIndex)"><mat-icon fontIcon="remove"></mat-icon></button>
         </div>
+        <button mat-button class="piece-form-buttons-add" (click)="addReward()"><mat-icon fontIcon="add"></mat-icon></button>
     </div>
 </div>
\ No newline at end of file

src/app/sider-pieces/rewards/rewards.component.scss

@@ -33,7 +33,28 @@
             padding: 5px 5px 5px 5px;
         }
 
+        button {
+            background-color: white;
+            border-radius: 10px;
+        }
+
+        &-buttons {
+
+            &-add {
+                margin-top: 10px;
+            }
+
+            &-remove {
+                position: relative;
+                left: 100%;
+                transform: translateX(-100%);
+            }
+        }
+
         &-content {
+            margin-top: 5px;
+            padding-bottom: 5px;
+            border-bottom: solid black 1px;
 
             &-type, &-name, &-object, &-character, &-skill {
                 margin-bottom: 5px;

src/app/sider-pieces/rewards/rewards.component.ts

 import { Component, OnInit, Input } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
 import { TranslateService } from '@ngx-translate/core';
+import { CharacterReward } from 'src/app/class/rewards/character-reward/character-reward';
+import { ObjectReward } from 'src/app/class/rewards/object-reward/object-reward';
+import { ObjectsReward } from 'src/app/class/rewards/objects-reward/objects-reward';
+import { SkillReward } from 'src/app/class/rewards/skill-reward/skill-reward';
 import { Role } from 'src/app/class/role/role';
 import { Scenario } from 'src/app/class/scenario/scenario';
 import { Task } from 'src/app/class/task/task';
 import { Trace } from 'src/app/class/trace/trace';
+import { SuppressDialogComponent } from 'src/app/components/dialogs/suppress-dialog/suppress-dialog.component';
 import { PieceDetailsService } from 'src/app/services/piece-details/piece-details.service';
 import { TooltipService } from 'src/app/services/tooltip/tooltip.service';
 
@@ -18,16 +24,11 @@ export class RewardsComponent implements OnInit {
   @Input() task: Task = new Task('normal');
   @Input() role: Role = new Role();
 
-  constructor(protected translate: TranslateService, protected tooltipService: TooltipService, protected pieceDetailsService: PieceDetailsService) { }
+  constructor(protected translate: TranslateService, protected tooltipService: TooltipService, protected pieceDetailsService: PieceDetailsService, public dialog: MatDialog) { }
 
   ngOnInit(): void {
   }
 
-  resetReward(event: any) {
-    this.task.resetReward();
-    this.editTrace(event, 'task_reward');
-  }
-
   formatTraceTarget(): string {
     let res: string = '';
 
@@ -45,11 +46,46 @@ export class RewardsComponent implements OnInit {
     return res;
   }
 
-  editTrace(event: any, source: string): void {
-    if (this.task.reward != undefined) {
-      this.scenario.traces.push(new Trace(this.scenario.traces.length,'Select_task_reward_'+this.task.rewardType,this.pieceDetailsService.missionIndex,this.pieceDetailsService.roleIndex,source,this.formatTraceTarget(), '#CFE3B9'));
-    } else {
-      this.scenario.traces.push(new Trace(this.scenario.traces.length,'Deselect_task_reward',this.pieceDetailsService.missionIndex,this.pieceDetailsService.roleIndex,source,this.formatTraceTarget(), '#CFE3B9'));
+  getCharacterReward(index: number): CharacterReward {
+    return this.task.rewards[index] as CharacterReward;
+  }
+
+  getSkillReward(index: number): SkillReward {
+    return this.task.rewards[index] as SkillReward;
+  }
+
+  getObjectReward(index: number): ObjectReward {
+    return this.task.rewards[index] as ObjectReward;
+  }
+
+  addReward(): void {
+    this.task.rewards.push(new ObjectReward());
+    this.scenario.traces.push(new Trace(this.scenario.traces.length,'new',this.pieceDetailsService.missionIndex,this.pieceDetailsService.roleIndex,'Reward_['+this.task.rewards.length+']', this.formatTraceTarget(), '#CFE3B9', '*'));
+  }
+
+  removeReward(index: number): void {
+    const dialogRef = this.dialog.open(SuppressDialogComponent, { data: this.translate.instant('role_reward_delete') });
+    dialogRef.afterClosed().subscribe(result => {
+      if (result == true) {
+        this.task.rewards.splice(index, 1);
+        this.scenario.traces.push(new Trace(this.scenario.traces.length,'delete',this.pieceDetailsService.missionIndex,this.pieceDetailsService.roleIndex,'Reward_['+this.task.rewards.length+']', this.formatTraceTarget(), '#CFE3B9', '*'));    
+      } else {
+        this.scenario.traces.push(new Trace(this.scenario.traces.length,'cancel_delete',this.pieceDetailsService.missionIndex,this.pieceDetailsService.roleIndex,'Reward_['+this.task.rewards.length+']', this.formatTraceTarget(), '#CFE3B9', '*'));        
+      }
+    });
+  }
+
+  changeRewardType(index: number, type: string): void {
+    switch(type) {
+      case 'object': this.task.rewards[index] = new ObjectsReward();
+        this.scenario.traces.push(new Trace(this.scenario.traces.length,'transform',this.pieceDetailsService.missionIndex,this.pieceDetailsService.roleIndex,'Reward_['+index+']_transform_into_[ObjectReward]',  this.formatTraceTarget(), '#CFE3B9', '*'));
+        break;
+      case 'skill': this.task.rewards[index] = new SkillReward();
+        this.scenario.traces.push(new Trace(this.scenario.traces.length,'transform',this.pieceDetailsService.missionIndex,this.pieceDetailsService.roleIndex,'Reward_['+index+']_transform_into_[SkillReward]',  this.formatTraceTarget(), '#CFE3B9', '*'));
+        break;
+      case 'character': this.task.rewards[index] = new CharacterReward();
+        this.scenario.traces.push(new Trace(this.scenario.traces.length,'transform',this.pieceDetailsService.missionIndex,this.pieceDetailsService.roleIndex,'Reward_['+index+']_transform_into_[CharacterReward]',  this.formatTraceTarget(), '#CFE3B9', '*')); 
+        break;
     }
   }
 }

src/assets/lang/en.json

@@ -399,8 +399,8 @@
     "legals_cookies_title": "Cookies",
     "legals_cookies_content": "We do not record any cookies and do not save any personal data!",
 
-    "rewards_tooltip": "Indicate the result obtained",
-    "rewards_title": "Result / Reward",
+    "rewards_tooltip": "Indicate the rewards obtained",
+    "rewards_title": "Results / Rewards",
     "rewards_type_label": "Type",
     "rewards_type_none": "None",
     "rewards_type_object": "Object",

src/assets/lang/fr.json

@@ -399,8 +399,8 @@
     "legals_cookies_title": "Cookies",
     "legals_cookies_content": "Nous n'enregistrons aucun cookie et ne sauvegardons aucune donnée personnelle !",
 
-    "rewards_tooltip": "Indiquer le résultat obtenu",
-    "rewards_title": "Résultat / Récompense",
+    "rewards_tooltip": "Indiquer les récompenses obtenues",
+    "rewards_title": "Résultats / Récompenses",
     "rewards_type_label": "Type",
     "rewards_type_none": "Aucune",
     "rewards_type_object": "Objet",