int d = y * 256 - h * 128 + lineHeight * 128; //256 and 128 factors to avoid floats
          int texY = ((d * texHeight) / lineHeight) / 256;
          int color = texture[texNum][texWidth * texY + texX];
          //make color darker for y-sides: R, G and B byte each divided through two with a "shift" and an "and"
          if(side == 1) color = (color >> 1) & 8355711;
          buffer[x][y] = color;

currentDist = h / (2.0 * y - h); //you could make a small lookup table for this instead

   double weight = (currentDist - distPlayer) / (distWall - distPlayer);

   double currentFloorX = weight * floorXWall + (1.0 - weight) * posX;
   double currentFloorY = weight * floorYWall + (1.0 - weight) * posY;

   int floorTexX, floorTexY;
   floorTexX = int(currentFloorX * texWidth) % texWidth;
   floorTexY = int(currentFloorY * texHeight) % texHeight;

   //floor
   buffer[x][y] = (texture[3][texWidth * floorTexY + floorTexX] >> 1) & 8355711;
   //ceiling (symmetrical!)
   buffer[x][h - y] = texture[6][texWidth * floorTexY + floorTexX];

    int d1=lineHeight * 128;
       int d2=h * 128;
       for(int y = drawStart; y < drawEnd; y++)
       {
        int d = y *256 - d2 + d1;  //256 and 128 factors to avoid floats
        int texY = ((d * texHeight) / lineHeight) >>8;
         Uint32 color =texture[texNum][texWidth * texY + texX];
         if(side == 1) color = (color >> 1) & 8355711;
         buffer[x][y] = color;
             }

d1 = lineHeight * 128 + h * 128

  int d = (y <<8) - d2 + d1;

#include <irrlicht.h>
#include <math.h>

#define MAX_FPS 100
#define IDLE_TIME  (1000 / MAX_FPS)

using namespace irr;

using namespace core;
using namespace scene;
using namespace video;
using namespace io;
using namespace gui;

#ifdef _IRR_WINDOWS_
#pragma comment(lib, "Irrlicht.lib")
#pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup")
#endif
f32 col[4];
IVideoDriver* driver;

int resw=800;// разрешение ёпта
int resh=600;

float offsetX=0, offsetY=0;

const int H = 12;
const int W = 40;

char* TileMap[H] = {

"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
"B                    B     B",
"B                    B     B",
"B                    B     B",
"B                    B     B",
"B         0000                BBBB     B",
"B                    B     B",
"BBB                    B     B",
"B              BB                BB    B",
"B              BB                      B",
"B    B         BB         BB           B",
"BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",

};

class PLAYER {

public:

float dx,dy;
rect<s32> rectan;
bool onGround;

float currentFrame;

     PLAYER()
    {
//    sprite.setTexture(image);
  rectan=rect<s32>(7*32,9*32,40,50);

  dx=dy=0.1;
  currentFrame = 0;
    }

    void update(float time)
    {

   rectan.left += dx * time;
   Collision(0);

   if (!onGround) dy=dy+0.0005*time;
   rect.top += dy*time;
   onGround=false;
      Collision(1);

    currentFrame += 0.005*time;
    if (currentFrame > 6) currentFrame -=6 ;

    if (dx>0) sprite.setTextureRect(IntRect(40*int(currentFrame),244,40,50));
    if (dx<0) sprite.setTextureRect(IntRect(40*int(currentFrame)+40,244,-40,50));

    sprite.setPosition(rect.left - offsetX, rect.top - offsetY);

    dx=0;
    }

    void Collision(int dir)
    {
      for (int i = rect.top/32 ; i<(rect.top+rect.height)/32; i++)
    for (int j = rect.left/32; j<(rect.left+rect.width)/32; j++)
   {
      if (TileMap[i][j]=='B')
      {
          if ((dx>0) && (dir==0)) rect.left =  j*32 -  rect.width;
       if ((dx<0) && (dir==0)) rect.left =  j*32 + 32;
    if ((dy>0) && (dir==1))  { rect.top =   i*32 -  rect.height;  dy=0;   onGround=true; }
    if ((dy<0) && (dir==1))  { rect.top = i*32 + 32;   dy=0;}
      }

    if (TileMap[i][j]=='0')
                      {
                     TileMap[i][j]=' ';
                      }

      }

    }
};

bool jumpf=false;

const int bitmapy=10,bitmapx=20;
//char bitmap[bitmapy][bitmapx];

char bitmap[bitmapy][bitmapx]= {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,
                    0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0,0,1,1,
                    1,1,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,1,1,1,
                    1,1,1,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,
                    1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,0,0,0,0,1,
                    1,1,1,1,1,0,0,0,1,1,1,0,0,0,0,0,0,1,1,1,
                    1,1,1,1,1,1,0,1,1,1,1,1,0,0,0,0,1,1,1,1,
                    1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,1,1,1,1,
                    1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};

s32 newMaterialType = 0;
class MyShaderCallBack : public IShaderConstantSetCallBack
{
public:

    virtual void OnSetConstants(IMaterialRendererServices* services,
          s32 userData)
    {
        // Передаём индекс(номер текстуры), в пиксельный(фрагментный шейдер)
     s32 TextureLayerID = 0;
        services->setPixelShaderConstant("myTexture", reinterpret_cast<f32*>(&TextureLayerID), 1);

         // Передаём во фрагментный шейдер нужный цвет

             services->setPixelShaderConstant("myColor", col, 4);

    }
    virtual void OnSetMaterial (const SMaterial &material)
    {
         Color = SColorf(material.AmbientColor);
    }
private:
     SColorf Color;
};

void createmat()
{

    io::path vsFileName; // filename for the vertex shader
    io::path psFileName; // filename for the pixel shader
    psFileName = "shdr/frag.glsl";
    vsFileName = "shdr/vert.glsl";

     // Создание нового шейдерного материала
    IGPUProgrammingServices* gpu = driver->getGPUProgrammingServices();

       MyShaderCallBack* mc = new MyShaderCallBack();

       newMaterialType = gpu->addHighLevelShaderMaterialFromFiles(
             vsFileName, "vertexMain", EVST_VS_1_1,
             psFileName, "pixelMain", EPST_PS_1_1,
             mc,EMT_TRANSPARENT_ALPHA_CHANNEL);
}

class MyEventReceiver : public IEventReceiver
{
public:
         // наш собственный обработчик событий
         virtual bool OnEvent(const SEvent& event)
         {
                 // просто запоминаем состояние любой клавиши - нажата/отжата
                 if (event.EventType == EET_KEY_INPUT_EVENT)
                         KeyIsDown[event.KeyInput.Key] = event.KeyInput.PressedDown;

                 return false;
         }

         // метод возвращающий состояние для запрошенной клавиши
         virtual bool IsKeyDown(EKEY_CODE keyCode) const
         {
                 return KeyIsDown[keyCode];
         }

         //конструктор, в цикле сбрасываем статус для всех клавиш
         MyEventReceiver()
         {
                 for (u32 i=0; i<KEY_KEY_CODES_COUNT; ++i)
                         KeyIsDown[i] = false;
         }

private:
         // массив для хранения статусов клавиш
         bool KeyIsDown[KEY_KEY_CODES_COUNT];
};

  MyEventReceiver receiver;

ICameraSceneNode* cam;
  IrrlichtDevice *device;
ISceneManager* smgr;

  ISceneNode* back;
  ISceneNode* pers;
  ISceneNode* fognod=0;
  ISceneNode* nebo;

ISceneNode* kub;

  ILightSceneNode* light;
IAnimatedMesh* mesh ;
ISceneNode* node = 0;

int maintimer = 0;

bool go=false;
int frametime;
bool rainflag = true;
  IParticleSystemSceneNode* ps;

  IBillboardSceneNode * bill1;
f32 fdt;

void move();
void movepers(int dir);
void water();
void addfog();
void setpar(vector3df pos,vector3df scal,char * mat);
void init();
void jump();

class MYgg
{

public:
float x,y;
ITexture * tex[10];

void movepers(int dir){
if(dir==1)
{
     x+=0.1;
     pers->setMaterialFlag( EMF_FRONT_FACE_CULLING, false);
pers->setMaterialFlag( EMF_BACK_FACE_CULLING, true);
}
if(dir==0.1)
{
     x-=1;
pers->setMaterialFlag( EMF_FRONT_FACE_CULLING, true);
pers->setMaterialFlag( EMF_BACK_FACE_CULLING, false);
}
pers->setPosition(vector3df(x*2600,y*2600,495));
light ->setPosition(vector3df(x,100,-400));
frametime+=1000*fdt;

if(frametime>00&&frametime<=100)pers->setMaterialTexture(0, tex[1]);//Эту шляпу
if(frametime>100&&frametime<=200)pers->setMaterialTexture(0, tex[2]);//можно было
if(frametime>200&&frametime<=300)pers->setMaterialTexture(0, tex[3]);//циклом зафигачить
if(frametime>300&&frametime<=400)pers->setMaterialTexture(0, tex[4]);
if(frametime>400&&frametime<=500)pers->setMaterialTexture(0, tex[5]);
if(frametime>500&&frametime<=600)pers->setMaterialTexture(0, tex[6]);
if(frametime>600&&frametime<=700)pers->setMaterialTexture(0, tex[7]);
if(frametime>700&&frametime<=800)pers->setMaterialTexture(0, tex[8]);

if(frametime>800)frametime=0;
go=true;
}

};
MYgg gg;

class MYcamera
{
public:
float posx;
float posz;
float posy;

};

MYcamera camera;

bool flrf;
class MYphys{

public : void collis(){

for(int i=gg.y-2;i<gg.y+2;i++)
{
     for(int j=gg.x-2;j<gg.x+2;j++)
     {
         if(i>=0 && i<=bitmapy && j>=0 && j<=bitmapx)
         {
             if(bitmap[i][j]==1 && i>0)flrf=true;
         }

     }
}

/*
for(int i=0;i<bitmapy;i++)
{
     for(int j=0;j<bitmapx;j++)
     {
          if(bitmap[i][j]== 1&&bitmap[i-1][j]== 1)
        {
            if(gg.x>=j*500+241&&gg.x<=j*500+480&&gg.y>=-i*500&&gg.y<=-i*500+480){
            gg.x+=80;
            pers->setPosition(vector3df(gg.x,gg.y,500));
            }
             if(gg.x>=j*500&&gg.x<=j*500+240&&gg.y>=-i*500&&gg.y<=-i*500+480){
            gg.x-=80;
            pers->setPosition(vector3df(gg.x,gg.y,500));
            }
        }

      if(bitmap[i][j]== 1&&bitmap[i-1][j]== 0)
        {
            if(gg.x>=j*500&&gg.x<=j*500+480&&gg.y>=-i*500&&gg.y<=-i*500+480){
            gg.y+=80;
            pers->setPosition(vector3df(gg.x,gg.y,500));
            flrf=false;
            }
        }

         if(bitmap[i][j]== 0) // пустота внизу
        {
            if(gg.x>=j*500&&gg.x<=j*500+480&&gg.y>=-i*500&&gg.y<=-i*500+480){
          flrf=false;
            }
        }
     }
}*/
}

public : void gravity()
{
if(flrf==false)
{
gg.y-=0.5;
}
}

};

MYphys phys;

class sky
{
public:void rain(){
if(rainflag==true){
rainflag = false;

  ps = smgr->addParticleSystemSceneNode(false);
   IParticleEmitter* em1 = ps->createBoxEmitter(
                 aabbox3d< f32 >(0,00,00,resw,1,1), // размер эмиттера(куба)
                vector3df(0.5f,-2.0f,0.0f),   // начальное направление
                 50,100,                             // частота испускания (мин,макс)
                 SColor(0,255,255,255),       // самый темный цвет
                 SColor(0,255,255,255),       // самый яркий цвет
                 400,800,30,                         // време жизни (мин,макс), угол
                 dimension2df(32.f,32.f),         // минимальный размер частиц
                dimension2df(96.f,32.f));        // максимальный размер частиц

         ps->setEmitter(em1); // отдаем эмиттер системе
         //em->drop(); // а лично нам он не нужен

         IParticleAffector* paf = ps->createFadeOutParticleAffector();

         ps->addAffector(paf); // отдаем аффектор системе и дропаем, т.к. нам он не нужен
         paf->drop();

         ps->setPosition(vector3df(gg.x,500,0));
         ps->setScale(vector3df(4,2,2));
         ps->setMaterialFlag(EMF_LIGHTING, false);
         ps->setMaterialFlag(EMF_ZWRITE_ENABLE, false);
         ps->setMaterialTexture(0, driver->getTexture("xyu\\list.png"));
         ps->setMaterialType(EMT_TRANSPARENT_VERTEX_ALPHA);
        //ps->setMaterialType(EMT_TRANSPARENT_ALPHA_CHANNEL);

}
};

public:void draw()
{
for(int i=0;i<resh;i++){
driver->draw2DLine(position2d<s32>(0,i),position2d<s32>(resw,i),SColor(255, 20,10,0+i/3));
}
if(rainflag==false)ps->setPosition(vector3df(gg.x-2500,1200,0));

};

public:void recolor()
{

};

};

class sloy
{
public: void create1(){
setpar(vector3df(8700,50,800),vector3df(320,320,0),"xyu\\bus.png");
setpar(vector3df(-256,-100,590),vector3df(723,256,0),"xyu\\home1.png");
setpar(vector3df(-256,0,501),vector3df(723,256,0),"xyu\\home2.png");

for(int i=-6000;i<18000;i+=6000){
setpar(vector3df(i,-1675,500),vector3df(600,80,0),"xyu\\ground1.png");
}

setpar(vector3df(5800,-650,501),vector3df(200,128,0),"xyu\\zabor1.png" );

setpar(vector3df(11000,-650,501),vector3df(200,128,0),"xyu\\zabor1.png" );
back->setMaterialFlag(EMF_BACK_FACE_CULLING,false);
back->setMaterialFlag(EMF_FRONT_FACE_CULLING,true);

setpar(vector3df(35000,620,2000),vector3df(850/1.2,760/1.2,0),"xyu\\rock.png");
setpar(vector3df(25000,20,-100),vector3df(397/1.5,387/1.5,0),"xyu\\tree.png");
setpar(vector3df(15950,-2320,497),vector3df(200,215,0),"xyu\\platform1.png");
setpar(vector3df(17700,-2200,500),vector3df(168,185,0),"xyu\\gorka.png");
setpar(vector3df(17700+1650,-2200-950,501),vector3df(168,185,0),"xyu\\gorka.png");
setpar(vector3df(17700+1735*2,-4200,495),vector3df(200,215,0),"xyu\\platform1.png");
setpar(vector3df(22970,-3700,500),vector3df(190,110,0),"xyu\\ground2.png");
setpar(vector3df(22970+1900,-3700,500),vector3df(190,110,0),"xyu\\ground2.png");
setpar(vector3df(35000,620,2000),vector3df(850/1.2,760/1.2,0),"xyu\\door.png");

};
};

sloy sloy1;

int main()
{
/*

int i=0;
int j=0;

  FILE *in;
   in=fopen("gav.no","r");
   char c;

//for(int i=0;i<bitmapy;i++)
  //  for(int j=0;j<bitmapx;j++)
  while ( (c=fgetc(in) ) != EOF )
{
   // while ( (c=fgetc(in) ) != EOF)

      //   c=fgetc(in);
if(c=='1'||c=='0'||c=='\n'){

              if(c=='\n'){
        i++;
        j=0;

         printf("\n");
        }

             bitmap[i][j]=c;
        j++;
        printf("%c",bitmap[i][j]);

}
             //fputc( c,out );//записываем переменную в файл data2.

}

*/
device =
   createDevice( EDT_OPENGL, dimension2d<u32>(resw, resh), 8,
    false, false, true, &receiver);

   device->getCursorControl()->setVisible(false);
  device->setWindowCaption(L"ALKO");

  driver = device->getVideoDriver();
smgr = device->getSceneManager();
//driver->setFog(SColor(50,255,255,255),
   //              EFT_FOG_LINEAR, 500, 5000, .001f, true, false);
init();

createmat();

//cam=smgr->addCameraSceneNodeFPS();
smgr->getActiveCamera()->setFarValue(10000);

light = smgr->addLightSceneNode(0, vector3df(500,1675,500),
                         SColorf(1.0f, 1.0f, 1.0f, 1.0f), 2500.0f);
device->getFileSystem()->addZipFileArchive("xyu\\xyu.penis");

u32 then = device->getTimer()->getTime();

//water();

for(int i=0;i<bitmapy;i++)
{

     for(int j=0;j<bitmapx;j++)
     {
      if(bitmap[i][j]== 1)
        {

         kub = smgr->addCubeSceneNode();
         kub->setPosition(vector3df(j*2600,-i*2600,500));
         kub->setScale(vector3df(190,190,0));

       }
     }

}

bill1 = smgr->addBillboardSceneNode();
bill1->setMaterialFlag(EMF_LIGHTING, false);
bill1->setMaterialType(EMT_TRANSPARENT_ADD_COLOR );
//bill1->setMaterialType(EMT_TRANSPARENT_VERTEX_ALPHA);
   bill1->setMaterialTexture(0,driver->getTexture("xyu\\sun.png"));
   bill1->setSize(dimension2d<f32>(8000.0f,8000.0f));
bill1->setPosition(vector3df(6000,3000,5500));
bill1->setMaterialFlag(EMF_BILINEAR_FILTER, false);

pers = smgr->addCubeSceneNode();
pers->setMaterialFlag(EMF_LIGHTING,false);

pers->setPosition(vector3df(gg.x,gg.y,500));
pers->setScale(vector3df(70,140,0));
pers->setMaterialTexture( 0, gg.tex[0] );

pers->setMaterialType(EMT_TRANSPARENT_ALPHA_CHANNEL_REF);
pers->setMaterialFlag(EMF_BILINEAR_FILTER, false);
//sloy1.create1();

/*
nebo = smgr->addCubeSceneNode();
nebo->setMaterialFlag(EMF_LIGHTING,false);
nebo->setPosition(vector3df(4800,810,2900));
nebo->setScale(vector3df(1600,230,0));
nebo->setMaterialTexture( 0, driver->getTexture("xyu\\tucha.png") );
nebo->setMaterialType(EMT_TRANSPARENT_ALPHA_CHANNEL);
//nebo->setMaterialFlag(EMF_FOG_ENABLE,true);
*/

sky sky1;

  while(device->run())
  {
      maintimer++;
      if((maintimer%100)==true)sky1.recolor();
const u32 now = device->getTimer()->getTime();
               fdt = (f32)(now - then) / 1000.f;
                 then = now;

  u32 time = device->getTimer()->getTime();

move();
jump();
camera.posx = gg.x;
camera.posy = gg.y;
camera.posz = -1200;

cam->setPosition(vector3df(camera.posx,camera.posy,camera.posz));
cam->setTarget(vector3df(gg.x,gg.y+100,1000));
//addfog();
   driver->beginScene(true, true, SColor(255,0, 40,40));
   pers->setPosition(vector3df(gg.x,gg.y,500));
sky1.draw();
sky1.rain();
phys.collis();
phys.gravity();
   smgr->drawAll();

   driver->endScene();
         device->sleep(IDLE_TIME - (time - device->getTimer()->getTime()));
  }

  device->drop();

  return 0;
}

void move(){

if(receiver.IsKeyDown(KEY_KEY_D)){
gg.movepers(1);
    }

if(receiver.IsKeyDown(KEY_KEY_A)){
gg.movepers(0);

    }
    if(receiver.IsKeyDown(KEY_KEY_S)){
    }
    if(receiver.IsKeyDown(KEY_KEY_W)){
        jumpf=true;

    }

if(go==false){pers->setMaterialTexture(0, gg.tex[0]);}
go=false;
}

void init(){
gg.tex[0]=driver->getTexture("xyu\\gg1.png");
gg.tex[1]=driver->getTexture("xyu\\gg2.png");
gg.tex[2]=driver->getTexture("xyu\\gg3.png");
gg.tex[3]=driver->getTexture("xyu\\gg4.png");
gg.tex[4]=driver->getTexture("xyu\\gg5.png");
gg.tex[5]=driver->getTexture("xyu\\gg6.png");
gg.tex[6]=driver->getTexture("xyu\\gg7.png");
gg.tex[7]=driver->getTexture("xyu\\gg8.png");
gg.tex[8]=driver->getTexture("xyu\\gg9.png");

gg.x=0;
gg.y=0;//=-580;
frametime=0;
cam=smgr->addCameraSceneNode(0, vector3df(0,0,00), vector3df(0,100,00));
cam->setPosition(vector3df(gg.x,gg.y,-1200));
cam->setTarget(vector3df(gg.x,gg.y+100,1000));
cam->setFOV(2);

}

void water()
{
driver->setFog(SColor(255,0,255,255),
                 EFT_FOG_LINEAR, 500, 5000, .0001f, true, false);

mesh = smgr->addHillPlaneMesh( "myHill",
   dimension2d<f32>(20,20),
   dimension2d<u32>(50,50), 0, 0,
   dimension2d<f32>(0,0),
  dimension2d<f32>(2,2));

  node = smgr->addWaterSurfaceSceneNode(mesh->getMesh(0), 300.0f, 2000.0f, 300.0f);
  node->setPosition(vector3df(-200,200,3000));
node->setRotation(vector3df(270,0,0));
node->setMaterialFlag(EMF_LIGHTING, false);
node->setMaterialFlag(EMF_GOURAUD_SHADING,false);
  node->setMaterialTexture(1, driver->getTexture("xyu\\water.jpg"));

  node->setMaterialType(EMT_REFLECTION_2_LAYER);
node->setScale(vector3df(20,1,5));
//node->setMaterialFlag(EMF_FOG_ENABLE,true);
}

void addfog(){
     if(fognod==0){
    fognod = smgr->addCubeSceneNode();
fognod->setMaterialFlag(EMF_LIGHTING,false);
fognod->setPosition(vector3df(-300,-1000,480));
fognod->setScale(vector3df(455,100,0));
fognod->setMaterialTexture( 0, driver->getTexture("xyu\\fog.png") );
fognod->setRotation(vector3df(0,0,180));
fognod->setMaterialType(EMT_TRANSPARENT_ALPHA_CHANNEL);

     }

}

void setpar(vector3df pos,vector3df scal,char * mat)
{
back = smgr->addCubeSceneNode();
back->setMaterialFlag(EMF_LIGHTING,false);

back->setScale(scal);
back->setPosition(pos);
back->setMaterialFlag(EMF_BILINEAR_FILTER, false);
back->setMaterialType(EMT_TRANSPARENT_ALPHA_CHANNEL_REF);
back->setMaterialTexture( 0, driver->getTexture(mat) );

col[0] = 0.7;
col[1]=0.0;
col[2]=0.2;
col[3]=0;
     back->setMaterialType((E_MATERIAL_TYPE)newMaterialType);

//back->setMaterialFlag(EMF_FOG_ENABLE,fog);
}

void jump()
{
     if(jumpf==true)
     {
         gg.y+=10;
     }
}