524 lines
16 KiB
Java
524 lines
16 KiB
Java
package com.rubenvandeven.emotionhero;
|
|
|
|
import android.graphics.Bitmap;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Color;
|
|
import android.graphics.Matrix;
|
|
import android.graphics.Paint;
|
|
import android.graphics.RectF;
|
|
import android.support.v8.renderscript.RenderScript;
|
|
import android.util.Log;
|
|
|
|
import com.affectiva.android.affdex.sdk.Frame;
|
|
import com.affectiva.android.affdex.sdk.detector.Face;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import java.util.Timer;
|
|
import java.util.TimerTask;
|
|
|
|
import io.github.silvaren.easyrs.tools.Nv21Image;
|
|
|
|
/**
|
|
* Created by ruben on 16/08/16.
|
|
*/
|
|
|
|
public class Scenario {
|
|
|
|
public int id;
|
|
|
|
public Frame.ByteArrayFrame currentFrame;
|
|
|
|
public static final int LVL_NONE = 0;
|
|
public static final int LVL_ANGER = 1;
|
|
public static final int LVL_JOY = 2;
|
|
public static final int LVL_SURPRISE = 3;
|
|
public static final int LVL_SADDNESS= 4;
|
|
|
|
// the levels in the right order.
|
|
public static final ArrayList<Integer> SCENARIOS = new ArrayList<Integer>() {{
|
|
add(LVL_JOY);
|
|
add(LVL_ANGER);
|
|
add(LVL_SADDNESS);
|
|
add(LVL_SURPRISE);
|
|
}};
|
|
|
|
static int DESIRED_FPS = 25;
|
|
|
|
float duration = 0;
|
|
|
|
/**
|
|
* Minimum score to be able to pass to the next level.
|
|
* (check minimumScore || minimumAchievements)
|
|
*/
|
|
float minimumScore = 0;
|
|
|
|
/**
|
|
* Number of achievements required to have, before being able to go to next level
|
|
* (check minimumScore || minimumAchievements)
|
|
*/
|
|
float minimumAchievements= 0;
|
|
|
|
/**
|
|
* Achievements one get obtain in this level
|
|
*/
|
|
ArrayList<Achievement> achievements = new ArrayList<>();
|
|
|
|
/**
|
|
* If a game is beign played.
|
|
*/
|
|
Game game;
|
|
|
|
/**
|
|
* @deprecated
|
|
*/
|
|
long startTime = 0;
|
|
|
|
/**
|
|
* The timer that provides the tick
|
|
*/
|
|
Timer timer;
|
|
|
|
/**
|
|
* Increment on each tick
|
|
*/
|
|
float runningTime = -1;
|
|
|
|
|
|
boolean isRunning = false;
|
|
|
|
private GamingActivity _activity;
|
|
|
|
int maxScore = 0;
|
|
|
|
protected RenderScript rs;
|
|
|
|
protected Paint squarePaint;
|
|
|
|
/**
|
|
* The scorres in this moment, as to draw them on the screen.
|
|
* Indexes are Emotion ordinals
|
|
*/
|
|
private Face currentFace;
|
|
|
|
ArrayList<Target> targets = new ArrayList<>();
|
|
|
|
class Target {
|
|
public int index;
|
|
public Emotion emotion;
|
|
public float value;
|
|
public float timestamp;
|
|
public boolean isHit = false;
|
|
}
|
|
|
|
/**
|
|
* Constructor
|
|
*/
|
|
public Scenario(int lvl_id, GamingActivity activity)
|
|
{
|
|
// go to first scenario if unexisting is given
|
|
if(!SCENARIOS.contains(lvl_id)) {
|
|
lvl_id = SCENARIOS.get(0);
|
|
}
|
|
|
|
this.id = lvl_id;
|
|
_activity = activity;
|
|
createTargets();
|
|
}
|
|
|
|
public void init() {
|
|
|
|
timer = new Timer("ScenarioTimer");
|
|
TimerTask tickTask;
|
|
tickTask = new TimerTask() {
|
|
@Override
|
|
public void run() {
|
|
// if (System.currentTimeMillis() - scheduledExecutionTime() >=
|
|
// MAX_TARDINESS)
|
|
// return; // Too late; skip this execution.
|
|
tick();
|
|
}
|
|
};
|
|
timer.schedule(tickTask, 0, 1000/DESIRED_FPS);
|
|
this.game = new Game(null, this, 0, 0, new Date(), null);
|
|
|
|
rs = RenderScript.create(_activity);
|
|
squarePaint = new Paint();
|
|
squarePaint.setColor(Color.YELLOW);
|
|
}
|
|
|
|
/**
|
|
* To be called on each timer tick
|
|
*/
|
|
public void tick()
|
|
{
|
|
if(!isRunning)
|
|
return;
|
|
|
|
runningTime += 1.0f/DESIRED_FPS;
|
|
|
|
if(isFinished()) {
|
|
stop();
|
|
return;
|
|
}
|
|
|
|
for(Target target: targets) {
|
|
// skip targets that are already scored
|
|
if(target.isHit == true) {
|
|
continue;
|
|
}
|
|
if(target.timestamp <= runningTime) {
|
|
Hit hit = new Hit(target, game, currentFace);
|
|
|
|
_activity.sound.play(_activity.soundIds.get(_activity.SOUND_SCORE), 1, 1,
|
|
2,0, hit.score / 200f + 0.5f ); // play back the sound slower
|
|
// depending on hit value
|
|
|
|
if(hit.bonus > 0) {
|
|
_activity.sound.play(_activity.soundIds.get(_activity.SOUND_BONUS), 0.7f, 0.7f,
|
|
1,0, hit.bonus / 100f + 0.8f ); // play back the sound slower
|
|
// depending on bonus value
|
|
}
|
|
target.isHit = true;
|
|
|
|
|
|
|
|
Bitmap outputBitmap = null;
|
|
if(currentFrame != null) {
|
|
// convert NV21 byteArrayFrame from camera to RGB bitmap.
|
|
Frame.ByteArrayFrame byteArrayFrame = (Frame.ByteArrayFrame) currentFrame;
|
|
outputBitmap = Nv21Image.nv21ToBitmap(rs, byteArrayFrame.getByteArray(), byteArrayFrame.getWidth(), byteArrayFrame.getHeight());
|
|
Frame.ROTATE rotation = byteArrayFrame.getTargetRotation();
|
|
// ie BY_90_CCW -90.0
|
|
Log.v("Scenario", "frame rotation: " + rotation.toString() + " " + rotation.toDouble());
|
|
// process rotation... (maybe faster if done on byte array?)
|
|
if(rotation != Frame.ROTATE.NO_ROTATION) {
|
|
Matrix matrix = new Matrix();
|
|
matrix.postRotate((int) rotation.toDouble());
|
|
// int width = rotation == Frame.ROTATE.BY_180 ? outputBitmap.getWidth() : outputBitmap.getHeight();
|
|
// int height = rotation == Frame.ROTATE.BY_180 ? outputBitmap.getHeight() : outputBitmap.getWidth();
|
|
outputBitmap = Bitmap.createBitmap(outputBitmap , 0, 0, outputBitmap .getWidth(), outputBitmap .getHeight(), matrix, true);
|
|
}
|
|
|
|
// Deprecated: now we send only fragments of the images anyway.
|
|
// Canvas canvas = new Canvas(outputBitmap);
|
|
// RectF rect = Hit.getBoundingboxForPoints(currentFace.getFacePoints());
|
|
// canvas.drawRect(rect, squarePaint);
|
|
|
|
/*
|
|
Also possible: only grayscale image - only loops over first part of the bytearray, is it faster?
|
|
int[] pixels;
|
|
int p;
|
|
int size = width*height;
|
|
for(int i = 0; i < size; i++) {
|
|
p = data[i] & 0xFF;
|
|
pixels[i] = 0xff000000 | p<<16 | p<<8 | p;
|
|
}
|
|
Bitmap bm = Bitmap.createBitmap(pixels, width, height, Bitmap.Config.ARGB_8888);
|
|
*/
|
|
}
|
|
|
|
hit.frame = outputBitmap;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public Target getTargetByIndex(int target_index) {
|
|
return targets.get(target_index-1);
|
|
}
|
|
|
|
/**
|
|
* Add a target on given timestamp
|
|
* @param emotion
|
|
* @param value
|
|
* @param timestamp
|
|
*/
|
|
public void setTarget(Emotion emotion, float value, float timestamp)
|
|
{
|
|
// Log.e(GamingActivity.LOG_TAG, "Set target:" + Float.toString(timestamp) + " " + Float.toString(duration));
|
|
if((timestamp + 1) > duration)
|
|
{
|
|
duration = timestamp + 1; // always a bit onger than last target, as it otherwise the game does not finish pretty
|
|
}
|
|
Target target = new Target();
|
|
target.timestamp = timestamp;
|
|
target.value = value;
|
|
target.emotion = emotion;
|
|
target.index = targets.size() + 1;
|
|
targets.add(target);
|
|
maxScore = getMaxScore();
|
|
}
|
|
|
|
/**
|
|
* Add target after existing targets, give delta with last item instead of absolute time.
|
|
* @param emotion
|
|
* @param value
|
|
* @param interval
|
|
*/
|
|
public void addTarget(Emotion emotion, float value, float interval)
|
|
{
|
|
float timestamp;
|
|
if(targets.isEmpty()) {
|
|
timestamp = interval;
|
|
} else {
|
|
timestamp = targets.get(targets.size() - 1).timestamp + interval;
|
|
}
|
|
setTarget(emotion, value, timestamp);
|
|
}
|
|
|
|
public float getHitTotalValue()
|
|
{
|
|
float value = 0;
|
|
for (Hit hit : game.hits.values()) {
|
|
value += hit.score;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
public float getHitTotalMisValue()
|
|
{
|
|
float value = 0;
|
|
for (Hit hit : game.hits.values()) {
|
|
value += 100-hit.score;
|
|
}
|
|
return value;
|
|
}
|
|
public float getBonusTotalValue()
|
|
{
|
|
float value = 0;
|
|
for (Hit hit : game.hits.values()) {
|
|
value += hit.bonus;
|
|
}
|
|
return value;
|
|
}
|
|
|
|
public float getHitPercentage() {
|
|
return (getHitTotalValue()/maxScore) * 100;
|
|
}
|
|
public float getBonusPercentage() {
|
|
// maxScore for bonus == normal maxScore
|
|
return (getBonusTotalValue()/maxScore) * 100;
|
|
}
|
|
|
|
public float getMissedPercentage() {
|
|
return (getHitTotalMisValue()/maxScore) * 100;
|
|
}
|
|
|
|
/**
|
|
* Check whether given timestamp is within duration of the scenario
|
|
* @param timestamp
|
|
* @return
|
|
*/
|
|
public boolean isWithinTime(float timestamp)
|
|
{
|
|
return timestamp <= duration;
|
|
}
|
|
|
|
public ArrayList<Target> getTargets() {
|
|
return targets;
|
|
}
|
|
|
|
|
|
/**
|
|
* Get the time within the scenario (so since start() has been called)
|
|
*/
|
|
public float getTime() {
|
|
return runningTime;
|
|
// if not started, don't move the labels, if started, move them by diff_y
|
|
// if(startTime == 0) {
|
|
// return 0;
|
|
// } else {
|
|
// float diff_t = ((System.currentTimeMillis() - startTime)) / (float) 1000;
|
|
// if(diff_t > duration) { // never larger than scenario duration
|
|
// return duration;
|
|
// }
|
|
// return diff_t;
|
|
// }
|
|
}
|
|
|
|
public void start()
|
|
{
|
|
startTime = System.currentTimeMillis();
|
|
isRunning = true;
|
|
}
|
|
|
|
public void pause() {
|
|
isRunning = false;
|
|
}
|
|
|
|
public void stop()
|
|
{
|
|
isRunning = false;
|
|
}
|
|
|
|
|
|
// TODO: create AttributeScoreCollection class, with this method.
|
|
public void setCurrentFace(Face face)
|
|
{
|
|
currentFace = face;
|
|
}
|
|
|
|
public boolean isFinished()
|
|
{
|
|
return runningTime > duration;
|
|
}
|
|
|
|
public Score getScore() {
|
|
if(!isFinished()) {
|
|
return null;
|
|
}
|
|
|
|
Score score = new Score(id, getHitTotalValue());
|
|
score.setTargets(targets);
|
|
return score;
|
|
}
|
|
|
|
public int getMaxScore() {
|
|
return targets.size() * 100;
|
|
}
|
|
|
|
public void createTargets() {
|
|
AchievementCollection achievementCollection = AchievementCollection.getInstance();
|
|
switch(id) {
|
|
case LVL_ANGER:
|
|
setTarget(Emotion.ANGER, 100, 1);
|
|
setTarget(Emotion.ANGER, 100, 2);
|
|
setTarget(Emotion.ANGER, 10, 3);
|
|
setTarget(Emotion.ANGER, 20, 4);
|
|
setTarget(Emotion.ANGER, 40, 5);
|
|
setTarget(Emotion.ANGER, 70, 6);
|
|
setTarget(Emotion.ANGER, 100, 7);
|
|
|
|
setMinimumScoreFromPercentage(10);
|
|
minimumAchievements = 2;
|
|
|
|
achievements.add(achievementCollection.get(1));
|
|
achievements.add(achievementCollection.get(3));
|
|
|
|
break;
|
|
case LVL_JOY:
|
|
setTarget(Emotion.JOY, 100, 1);
|
|
setTarget(Emotion.JOY, 100, 2);
|
|
setTarget(Emotion.JOY, 100, 4);
|
|
setTarget(Emotion.CONTEMPT, 20, 4);
|
|
setTarget(Emotion.ANGER, 100, 5);
|
|
setTarget(Emotion.JOY, 100, 7);
|
|
setTarget(Emotion.ANGER, 100, 9);
|
|
setTarget(Emotion.JOY, 100, 11);
|
|
setTarget(Emotion.JOY, 70, 12);
|
|
setTarget(Emotion.JOY, 60, 13);
|
|
setTarget(Emotion.JOY, 30, 14);
|
|
setTarget(Emotion.JOY, 10, 14.5f);
|
|
setTarget(Emotion.ANGER, 100, 16);
|
|
setTarget(Emotion.JOY, 100, 17);
|
|
setTarget(Emotion.JOY, 100, 18);
|
|
setTarget(Emotion.JOY, 100, 19);
|
|
setTarget(Emotion.JOY, 100, 20);
|
|
|
|
|
|
setMinimumScoreFromPercentage(10);
|
|
minimumAchievements = 2;
|
|
|
|
|
|
achievements.add(achievementCollection.get(2));
|
|
achievements.add(achievementCollection.get(4));
|
|
|
|
break;
|
|
case LVL_SURPRISE:
|
|
setTarget(Emotion.SURPRISE, 20, 1);
|
|
setTarget(Emotion.SURPRISE, 50, 2);
|
|
setTarget(Emotion.SURPRISE, 80, 3);
|
|
setTarget(Emotion.SURPRISE, 100, 4);
|
|
|
|
setMinimumScoreFromPercentage(10);
|
|
minimumAchievements = 2;
|
|
|
|
achievements.add(achievementCollection.get(5));
|
|
achievements.add(achievementCollection.get(6));
|
|
|
|
break;
|
|
case LVL_SADDNESS:
|
|
setTarget(Emotion.SADNESS, 20, 1);
|
|
setTarget(Emotion.SADNESS, 50, 2);
|
|
setTarget(Emotion.SADNESS, 80, 3);
|
|
setTarget(Emotion.SADNESS, 100, 4);
|
|
|
|
setMinimumScoreFromPercentage(10);
|
|
minimumAchievements = 2;
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
public void setMinimumScoreFromPercentage(float percentage) {
|
|
this.minimumScore = maxScore * (percentage / 100f);
|
|
}
|
|
|
|
public int getNextLevelId() {
|
|
int nextIdx = SCENARIOS.indexOf(id) + 1;
|
|
if(SCENARIOS.size() <= nextIdx) {
|
|
return SCENARIOS.get(0);
|
|
}
|
|
return SCENARIOS.get(nextIdx);
|
|
}
|
|
|
|
public boolean isFinalLevel() {
|
|
if(SCENARIOS.get(SCENARIOS.size()-1) == id)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
public boolean isHigherThen(int lvl_id) {
|
|
return isHigherLevel(id, lvl_id);
|
|
}
|
|
|
|
public static boolean isHigherLevel(int lvl_id, int then_lvl_id) {
|
|
if(lvl_id == then_lvl_id) {
|
|
return false;
|
|
}
|
|
|
|
return SCENARIOS.indexOf(lvl_id) > SCENARIOS.indexOf(then_lvl_id);
|
|
}
|
|
|
|
public String toString() {
|
|
|
|
switch(id) {
|
|
case LVL_ANGER:
|
|
return "\"Smile like you mean it\"";
|
|
case LVL_JOY:
|
|
return "The seven";
|
|
case LVL_SURPRISE:
|
|
return "\"Let's talk business\"";
|
|
case LVL_SADDNESS:
|
|
return "A sad sad situation";
|
|
}
|
|
return "...";
|
|
}
|
|
|
|
public String getDescription() {
|
|
|
|
switch(id) {
|
|
case LVL_ANGER:
|
|
return "You're CEO of a big company. Remarkably, research shows that CEO's of big companies look generally more angry and disgusted when the company is doing well.\n" +
|
|
"\n" +
|
|
"However, you're company is not doing well. Make sure you hide this for the press that is watching every move!";
|
|
case LVL_JOY:
|
|
return "You're at a job interview, and you know your face is being monitored.\n" +
|
|
"Make sure that you express your enthusiasm for the job!";
|
|
case LVL_SURPRISE:
|
|
return "Your friends have organised a surprise party and you've found out! However, you don't want them to know this. First keep calm and then make sure you're as surprised and joyful as possible!\n";
|
|
case LVL_SADDNESS:
|
|
return "You're at the funeral of your great aunt. You don't really know her, but still want to show your respect.";
|
|
}
|
|
return "...";
|
|
}
|
|
|
|
public Hit getHitForTarget(Target target) {
|
|
return game.hits.get(target.index);
|
|
}
|
|
|
|
}
|