Topic blabla

// FaceIsoLocation header
enum SpecifyDirection {
  eUp,
  eLeft,
  eRight,
  eDown,
  eNone
};

import float FIL_Applatissement;
import void FaceIsoDirection(this Character*, SpecifyDirection=eNone, BlockingStyle=eBlock);
import void FaceIsoLocation(this Character*, int x, int y, BlockingStyle BStyle = eBlock);
import void FaceIsoCharacter(this Character*, Character* toFace, BlockingStyle BStyle = eBlock);
import void FaceIsoObject(this Character*, Object* toFace, BlockingStyle BStyle = eBlock);
import void FIL_SetApplatissment(int horizonY);

// FaceIsoLocation script

float FIL_Applatissement = 0.5;
float FIL_TheAngle;


float FIL_Abs(float x) {
 if (x >= 0.0) return x;
  else return -1.0*x;
}

void FaceIsoDirection(this Character*, SpecifyDirection Dir, BlockingStyle BStyle)
{
    if(Dir == eUp) this.FaceLocation(this.x, this.y-1, BStyle);
    else if(Dir == eLeft) this.FaceLocation(this.x-1, this.y, BStyle);
    else if(Dir == eRight) this.FaceLocation(this.x+1, this.y, BStyle);
    else if(Dir == eDown) this.FaceLocation(this.x, this.y+1, BStyle);
}

void FaceIsoLocation(this Character*, int x, int y, BlockingStyle BStyle)
{
    FIL_TheAngle = Maths.ArcCos(FIL_Applatissement)/2.0;
    
    int x0 = this.x;
    int y0 = this.y;
    int deltaX = x - x0;
    int deltaY = y0 - y; //AGS Y axes is pointing down
    
    float deltaXf = IntToFloat(deltaX);
    float deltaYf = IntToFloat(deltaY);
    
    float alpha = Maths.ArcTan2(deltaYf, deltaXf);
    
    if (deltaXf >= 0.0 && FIL_Abs(alpha) <= FIL_Abs(FIL_TheAngle)) {
        this.FaceIsoDirection(eRight, BStyle);
    } else if (deltaXf < 0.0 && FIL_Abs(alpha) <= FIL_Abs(FIL_TheAngle)) {
        this.FaceIsoDirection(eLeft, BStyle);
    } else if (deltaYf >=0.0) {
        this.FaceIsoDirection(eUp, BStyle);
    } else {
        this.FaceIsoDirection(eDown, BStyle);
    }
}

void FaceIsoCharacter(this Character*, Character* toFace, BlockingStyle BStyle)
{
    this.FaceIsoLocation(toFace.x, toFace.y, BStyle);
}

void FaceIsoObject(this Character*, Object* toFace, BlockingStyle BStyle)
{
    int x,  y;
    x = toFace.X + Game.SpriteWidth[toFace.Graphic]/2;
    y = toFace.Y - Game.SpriteHeight[toFace.Graphic]/2;
    this.FaceIsoLocation( x, y, BStyle);
}

void FIL_SetApplatissment(int horizonY) {
    if (horizonY >= 0 && horizonY <= Room.Height) {
        float horizonYf;
        horizonYf = IntToFloat(horizonY);
        int RoomHeight = Room.Height;
        float RoomHeightf = IntToFloat(RoomHeight);
    
        FIL_Applatissement = -1.0 *(horizonYf / RoomHeightf) + 1.0;
    }
}

export FIL_Applatissement;

// FaceIsoLocation header

enum SpecifyDirection {
  eUp,
  eLeft,
  eRight,
  eDown,
  eUpRight,
  eUpLeft,
  eDownRight,
  eDownLeft,
 eNone
};

struct SideViewFL {
    
    import static attribute float Angle4Dir;
    import static float get_Angle4Dir();// $AUTOCOMPLETEIGNORE$
    import static void set_Angle4Dir(float input);// $AUTOCOMPLETEIGNORE$
    
    import static attribute float Angle8Dir1;
    import static float get_Angle8Dir1();// $AUTOCOMPLETEIGNORE$
    import static void set_Angle8Dir1(float input);
    import static attribute float Angle8Dir2;
    import static float get_Angle8Dir2();// $AUTOCOMPLETEIGNORE$
    import static void set_Angle8Dir2(float input);// $AUTOCOMPLETEIGNORE$
    
    import static attribute float Flatness;
    import static float get_Flatness();// $AUTOCOMPLETEIGNORE$
    import static void set_Flatness(float input);// $AUTOCOMPLETEIGNORE$
    
    import static attribute int HorizonLevel;
    import static int get_HorizonLevel();// $AUTOCOMPLETEIGNORE$
    import static void set_HorizonLevel(int input);// $AUTOCOMPLETEIGNORE$
    
    import static void CharacterWithDiagonalLoops(Character *chara,  bool boule);
};

import void FaceSVDirection(this Character*, SpecifyDirection=eNone, BlockingStyle=eBlock);
import void FaceSVLocation(this Character*, int x, int y, BlockingStyle BStyle = eBlock);
import void FaceSVCharacter(this Character*, Character* toFace, BlockingStyle BStyle = eBlock);
import void FaceSVObject(this Character*, Object* toFace, BlockingStyle BStyle = eBlock);

// FaceIsoLocation script

float Angle4Dir;
float Angle8Dir1;
float Angle8Dir2;
float Flatness;
int HorizonLevel;
bool IsCharacterWithDiagonalLoops[];

// Utilitary function
float SideView_Abs(float x) // return absolute value
{
 if (x >= 0.0) return x;
  else return -1.0*x;
}

// struct static definitions
static float SideViewFL::get_Angle4Dir()
{
    return Angle4Dir;
}

static void SideViewFL::set_Angle4Dir(float input)
{
    if (input >= 0.0 && input <= Maths.Pi/2.0) {
        Angle4Dir = input;
    }
}

static float SideViewFL::get_Angle8Dir1()
{
    return Angle8Dir1;
}

static void SideViewFL::set_Angle8Dir1(float input)
{
    if (input >= 0.0 && input <= Maths.Pi/2.0 && input <= Angle8Dir2) {
        Angle8Dir1 = input;
    }
}

static float SideViewFL::get_Angle8Dir2()
{
    return Angle8Dir2;
}

static void SideViewFL::set_Angle8Dir2(float input)
{
    if (input >= 0.0 && input <= Maths.Pi/2.0 && input >= Angle8Dir1) {
        Angle8Dir2 = input;
    }
}

static float SideViewFL::get_Flatness()
{
    return Flatness;
}

static void SideViewFL::set_Flatness(float input)
{
    if (input >= 0.0 && input <= 1.0) {
        Flatness = input;
        Angle4Dir = Maths.ArcCos(Flatness)/2.0;
        Angle8Dir1 = Maths.ArcCos(Flatness)/6.0;
        Angle8Dir2 = Maths.ArcCos(Flatness)/3.0;
    }
}

static int SideViewFL::get_HorizonLevel()
{
    return HorizonLevel;
}

static void SideViewFL::set_HorizonLevel(int input)
{
    if (input >= 0 && input <= Room.Height) {
        float horizonYf;
        horizonYf = IntToFloat(input);
        int RoomHeight = Room.Height;
        float RoomHeightf = IntToFloat(RoomHeight);
        SideViewFL.Flatness = -1.0 *(horizonYf / RoomHeightf) + 1.0; //Linear decrease of flatness. Probably not the best model. Arctan ?
   }
}

static void SideViewFL::CharacterWithDiagonalLoops(Character *chara,  bool boule)
{
    IsCharacterWithDiagonalLoops[chara.ID] = boule;
}

// Module core functions
void FaceSVDirection(this Character*, SpecifyDirection Dir, BlockingStyle BStyle)
{
    if(Dir == eUp) this.FaceLocation(this.x, this.y-1, BStyle);
    else if(Dir == eLeft) this.FaceLocation(this.x-1, this.y, BStyle);
    else if(Dir == eRight) this.FaceLocation(this.x+1, this.y, BStyle);
    else if(Dir == eDown) this.FaceLocation(this.x, this.y+1, BStyle);
    else if(Dir == eUpRight) this.FaceLocation(this.x+1, this.y-1, BStyle);
    else if(Dir == eUpLeft) this.FaceLocation(this.x-1, this.y-1, BStyle);
    else if(Dir == eDownRight) this.FaceLocation(this.x+1, this.y+1, BStyle);
    else if(Dir == eDownLeft) this.FaceLocation(this.x-1, this.y+1, BStyle);
}

void FaceSVLocation(this Character*, int x, int y, BlockingStyle BStyle)
{
    int deltaX = x - this.x;
    int deltaY = this.y - y; //AGS Y axes is pointing down
    float deltaXf = IntToFloat(deltaX);
    float deltaYf = IntToFloat(deltaY);
    float alpha = Maths.ArcTan2(deltaYf, deltaXf);
    if (!IsCharacterWithDiagonalLoops[this.ID]) { // Four loops character
        if (deltaX >= 0 && SideView_Abs(alpha) <= SideViewFL.Angle4Dir) {
            this.FaceSVDirection(eRight, BStyle);
        } else if (deltaX < 0 && SideView_Abs(alpha) <= SideViewFL.Angle4Dir) {
            this.FaceSVDirection(eLeft, BStyle);
        } else if (deltaY >0) {
            this.FaceSVDirection(eUp, BStyle);
        } else {
            this.FaceSVDirection(eDown, BStyle);
        }
    } else { // Eight loops character
        if (deltaX >= 0 && SideView_Abs(alpha) <= SideViewFL.Angle8Dir1) {
            this.FaceSVDirection(eRight, BStyle);
        } else if (deltaX >= 0 && SideView_Abs(alpha) <= SideViewFL.Angle8Dir2) {
            if (deltaY >=0) {
                this.FaceSVDirection(eUpRight, BStyle);
            } else {
                this.FaceSVDirection(eDownRight, BStyle);
            }
        } else if (deltaX < 0 && SideView_Abs(alpha) <= SideViewFL.Angle8Dir1) {
            this.FaceSVDirection(eLeft, BStyle);
        } else if (deltaX < 0 && SideView_Abs(alpha) <= SideViewFL.Angle8Dir2) {
            if (deltaY >=0) {
                this.FaceSVDirection(eUpLeft, BStyle);
            } else {
                this.FaceSVDirection(eDownRight, BStyle);
            }
        } else if (deltaY >=0) {
            this.FaceSVDirection(eUp, BStyle);
        } else {
            this.FaceSVDirection(eDown, BStyle);
        }
    }
}

void FaceSVCharacter(this Character*, Character* toFace, BlockingStyle BStyle)
{
    this.FaceSVLocation(toFace.x, toFace.y, BStyle);
}

void FaceSVObject(this Character*, Object* toFace, BlockingStyle BStyle)
{
    int x, y;
    x = toFace.X + Game.SpriteWidth[toFace.Graphic]/2;
    y = toFace.Y - Game.SpriteHeight[toFace.Graphic]/2;
    this.FaceSVLocation( x, y, BStyle);
}

function game_start () {
    IsCharacterWithDiagonalLoops = new bool[Game.CharacterCount];
    int i = 0;
    while (i < Game.CharacterCount) {
        IsCharacterWithDiagonalLoops[i] = false;
        i++;
    }
    SideViewFL.set_Flatness(0.5);
}

t <- data.frame("gene_id"=c("ENSG000000001.1","ENSG000000042.5","2018","ENSG000000787.3"), "RPKM"=c(10.53,0,1.2,4), stringsAsFactors =FALSE)
v <- c("ENSG000000042", "ENSG000000787")
subset(t, grepl(paste("^(",paste(v, collapse='|'),")\\.\\d$", sep=''), gene_id))$RPKM

c <- sapply(v, function(x) grepl(paste("^",x,"\\.\\d+$",sep=""),t$gene_id))
t$RPKM[sapply(as.data.frame(t(c)), any)]