Page 3 of 5 FirstFirst 12345 LastLast
Results 21 to 30 of 42

Thread: Making a platform game - few questions

  1. #21

    Making a platform game - few questions

    PS. change LESS_THAN to < in the above post.

    I had to change it because the code kept getting screwing up as it thought the <and> meant some special part

    cheers,
    Paul

  2. #22

    Making a platform game - few questions

    If it isn't obvious, the top left of the sprite is at (x - w / 2),(y - h / 2), so this means the center of the sprite is at x,y

    cheers,
    Paul

  3. #23

    Making a platform game - few questions

    Here is some actual working code.

    Again, replace "LESS_THAN" with the less than character.

    This now includes moving left and right as well.

    [pascal]Const
    {................................................. .............................}
    cMapWidth = 20;
    cMapHeight = 20;
    cTileWidth = 20;
    cTileHeight = 16;
    {................................................. .............................}

    Type
    {................................................. .............................}
    TTile = Record
    id : Integer;
    IsSolid : Boolean;
    End;
    {................................................. .............................}

    {................................................. .............................}
    TPoint = Record
    x,y : Integer;
    End;
    {................................................. .............................}

    {................................................. .............................}
    TPlayer = Class
    Public
    x : Single;
    y : Single;
    vx : Single;
    vy : Single;
    w : Integer;
    h : Integer;
    CnrUL : TPoint; // upper left tile (x,y) player is over
    CnrUR : TPoint; // upper right tile (x,y) player is over
    CnrLL : TPoint; // lower left tile (x,y) player is over
    CnrLR : TPoint; // lower right tile (x,y) player is over
    Private
    Procedure GetCornersAt(Const ax,ay : Single);
    Public
    Procedure Update(Const ATimeSlice : Single);
    End;
    {................................................. .............................}

    Var
    Tiles : Array[0..cMapHeight - 1,0..cMapWidth - 1] Of TTile;
    {................................................. .............................}

    {................................................. .............................}
    Function Floor(X : Extended) : Integer;
    Begin
    Result := Integer(Trunc(X));
    If Frac(X) LESS_THAN 0 Then Dec(Result);
    End;
    {................................................. .............................}

    {................................................. .............................}
    Function TileIsWalkable(Const tx,ty : Integer) : Boolean;
    Begin
    Result := False;
    If tx LESS_THAN 0 Then Exit;
    If ty LESS_THAN 0 Then Exit;
    If tx >= cMapWidth Then Exit;
    If ty >= cMapHeight Then Exit;
    Result := Not Tiles[ty,tx].IsSolid;
    End;
    {................................................. .............................}

    {................................................. .............................}
    Function ClampValue(Const n,l,u : Integer) : Integer;
    Begin
    Result := n;
    If Result LESS_THAN l Then Result := l
    Else
    If Result > u Then Result := u;
    End;
    {................................................. .............................}

    {................................................. .............................}
    Procedure TPLayer.GetCornersAt(Const ax,ay : Single);
    {
    |
    |
    -,- | +,-

    -------|-------

    -,+ | +,+
    |
    |
    }
    Begin
    CnrUL.x := Floor((ax - w/2) / cTileWidth);
    CnrUL.y := Floor((ay - h/2) / cTileHeight);

    CnrUR.x := Floor((ax + w/2) / cTileWidth);
    CnrUR.y := Floor((ay - h/2) / cTileHeight);

    CnrLR.x := Floor((ax + w/2) / cTileWidth);
    CnrLR.y := Floor((ay + h/2) / cTileHeight);

    CnrLL.x := Floor((ax - w/2) / cTileWidth);
    CnrLL.y := Floor((ay + h/2) / cTileHeight);

    CnrUL.x := ClampValue(CnrUL.x,0,cMapWidth - 1);
    CnrUR.x := ClampValue(CnrUR.x,0,cMapWidth - 1);
    CnrLR.x := ClampValue(CnrLR.x,0,cMapWidth - 1);
    CnrLL.x := ClampValue(CnrLL.x,0,cMapWidth - 1);

    CnrUL.y := ClampValue(CnrUL.y,0,cMapHeight - 1);
    CnrUR.y := ClampValue(CnrUR.y,0,cMapHeight - 1);
    CnrLR.y := ClampValue(CnrLR.y,0,cMapHeight - 1);
    CnrLL.y := ClampValue(CnrLL.y,0,cMapHeight - 1);
    End;
    {................................................. .............................}

    {................................................. .............................}
    Procedure TPlayer.Update(Const ATimeSlice : Single);
    Var
    TileIsWalkableUL : Boolean; // upper left player corner tile is walkable
    TileIsWalkableUR : Boolean; // upper right player corner tile is walkable
    TileIsWalkableLL : Boolean; // lower left player corner tile is walkable
    TileIsWalkableLR : Boolean; // lower right player corner tile is walkable
    Begin
    GetCornersAt(x,y + vy * ATimeSlice);
    If vy LESS_THAN 0 Then
    //moving up
    Begin
    TileIsWalkableUL := TileIsWalkable(CnrUL.x,CnrUL.y);
    TileIsWalkableUR := TileIsWalkable(CnrUR.x,CnrUR.y);
    If TileIsWalkableUL And TileIsWalkableUR Then
    y := y + vy * ATimeSlice
    Else
    // move player to touch tiles(s) above
    y := CnrUL.y * cTileHeight + cTileHeight + h/2 + 0.01;
    End
    Else
    If vy > 0 Then
    //moving down
    Begin
    TileIsWalkableLL := TileIsWalkable(CnrLL.x,CnrLL.y);
    TileIsWalkableLR := TileIsWalkable(CnrLR.x,CnrLR.y);
    If TileIsWalkableLL And TileIsWalkableLR Then
    y := y + vy * ATimeSlice
    Else
    // move player to sit on tile(s) below
    y := CnrLR.y * cTileHeight - h/2 - 0.01;
    End;

    GetCornersAt(x + vx * ATimeSlice,y);
    If vx LESS_THAN 0 Then
    //moving left
    Begin
    TileIsWalkableUL := TileIsWalkable(CnrUL.x,CnrUL.y);
    TileIsWalkableLL := TileIsWalkable(CnrLL.x,CnrLL.y);
    If TileIsWalkableUL And TileIsWalkableLL Then
    x := x + vx * ATimeSlice
    Else
    // move player to touch tiles(s) on left
    x := CnrUL.x * cTileWidth + cTileWidth + w/2 + 0.01;
    End
    Else
    If vx > 0 Then
    //moving right
    Begin
    TileIsWalkableUR := TileIsWalkable(CnrUR.x,CnrUR.y);
    TileIsWalkableLR := TileIsWalkable(CnrLR.x,CnrLR.y);
    If TileIsWalkableUR And TileIsWalkableLR Then
    x := x + vx * ATimeSlice
    Else
    // move player to touch tile(s) on right
    x := CnrUR.x * cTileWidth - w/2 - 0.01;
    End;
    // add gravity to vy here and cap to max velocity so not faster than tile height;
    End;[/pascal]

    This is how I am using it:

    [pascal] FPlayer := TPlayer.Create;
    FPlayer.w := cTileWidth - 5;
    FPlayer.h := cTileHeight - 5;
    FPlayer.x := cMapWidth * cTileWidth / 2;
    FPlayer.y := cMapHeight * cTileHeight / 2;
    FPlayer.vx := 0;
    FPlayer.vy := 0;

    [/pascal]

    [pascal]
    FPlayer.vx := 0;
    FPlayer.vy := 0;
    If FMoveUp Then
    FPlayer.vy := -cPlayerSpeed
    Else
    If FMoveDown Then
    FPlayer.vy := +cPlayerSpeed;

    If FMoveLeft Then
    FPlayer.vx := -cPlayerSpeed
    Else
    If FMoveRight Then
    FPlayer.vx := +cPlayerSpeed;

    FPlayer.Update(TimeSlice);
    [/pascal]

    where TimeSlice is the time for the last frame in seconds (floating point)

    Cheers,
    Paul

  4. #24

    Making a platform game - few questions

    Thanks.
    I'm still trying to figure out what you did here, as I'm not really used to using classes and such.

    But I'll figure it out.

  5. #25

    Making a platform game - few questions

    :cry:

    Still stuck with this.
    I just can't follow your code, as I don't understand some parts of it (for example, how can variable Result have an integer value in Floor Function, while it's a boolean in TileIsWalkable function. And from what I see here, Result is a global var... :?

    If it's possible, could you write just pseudo code? Or just explain without the code exactly what you did. I just need a procedure for checking if player is standing on a solid tile (and if a tile left or right from him is walkable).

    I have solved gravity, acceleration, movement (left, right etc...) and that kind of stuff.

    Thanks for your help!

  6. #26

    Making a platform game - few questions

    Quote Originally Posted by Ixy
    :cry:

    Still stuck with this.
    I just can't follow your code, as I don't understand some parts of it (for example, how can variable Result have an integer value in Floor Function, while it's a boolean in TileIsWalkable function. And from what I see here, Result is a global var... :?

    If it's possible, could you write just pseudo code? Or just explain without the code exactly what you did. I just need a procedure for checking if player is standing on a solid tile (and if a tile left or right from him is walkable).

    I have solved gravity, acceleration, movement (left, right etc...) and that kind of stuff.

    Thanks for your help!
    are you a c++ coder? :shock:

    Result is not a global variable, inside a function it works like return

    return 1; is the same as Result := 1, only difference is delphi does not ret on a result, where as c/c++ does.

    to be more precise, Result is a local variable (as the function return type), that is returned at the end of the function, or at an exit.

    ;MM;

  7. #27

    Making a platform game - few questions



    No, I'm not a c coder, but I never came across something like that.
    I'm still in high school, and they don't teach us anything but basic programming.

  8. #28

    Making a platform game - few questions

    hi folks!

    after reading that post i fell like i should start making a platformer

    well, i also got stuck after reading tonypa's tutorial while implementing the corners stuff. well, half stuck, my player still could move to the left ops:

    what i want to say is thanks paul nicholls, i implemented your code into mine and it's working fine! now i just have to find out why and clean up the mess i left so thanks a lot!

    different to paul, i have two classes tsimpleplayer and tsimplemap which are both controlled by a class named tsimplegame, where i do all this collision stuff.

    i think i'll post the source, just to copy and paste

  9. #29

    Making a platform game - few questions

    unit '__pf_simpleplayer'

    Code:
    unit __pf_simpleplayer;
    
    interface
    
    uses Windows,
         Messages,
         SysUtils,
         Variants,
         Classes,
         Graphics,
         Controls,
         Forms,
         Dialogs,
         DJXTimer,
         DJX,
         ExtCtrls,
         djxclasses,
         d3dx9,
         StdCtrls,
         DJXFonts,
         ComCtrls,
         djxlandscape,
         djxtextures,
         Direct3D9,
         djxrender,
         djxmeshes,
         DJXMaterials,
         DJXLights,
         __dxtexturemanager;
    
    type tpf_simpleplayer= class
                             public
                               constructor create;
    
                               procedure render;
                             private
                               fdjx&#58; tdanjetx;
                               ftm&#58; tdxtexturemanager;
                               fnameintl&#58; string;
                               fstretch_x,
                               fstretch_y&#58; single;
    
                               fx,
                               fy&#58; integer;
    
                               fpos_x,
                               fpos_y&#58; single;
    
                               fwidth,
                               fheight&#58; integer;
                                
                               procedure setdjx&#40;const value&#58; tdanjetx&#41;;
                               procedure setnameintl&#40;const value&#58; string&#41;;
                               procedure settm&#40;const value&#58; tdxtexturemanager&#41;;
                               procedure setstretch_x&#40;const value&#58; single&#41;;
                               procedure setstretch_y&#40;const value&#58; single&#41;;
                               procedure setx&#40;const value&#58; integer&#41;;
                               procedure sety&#40;const value&#58; integer&#41;;
                               procedure setpos_x&#40;const value&#58; single&#41;;
                               procedure setpos_y&#40;const value&#58; single&#41;;
                             published
                               property djx&#58; tdanjetx read fdjx write setdjx;
                               property texturemanager&#58; tdxtexturemanager read ftm write settm;
                               property nameintl&#58; string read fnameintl write setnameintl;
                               property stretch_x&#58; single read fstretch_x write setstretch_x;
                               property stretch_y&#58; single read fstretch_y write setstretch_y;
                               property x&#58; integer read fx write setx;
                               property y&#58; integer read fy write sety;
                               property width&#58; integer read fwidth;
                               property height&#58; integer read fheight;
                               property pos_x&#58; single read fpos_x write setpos_x;
                               property pos_y&#58; single read fpos_y write setpos_y;
                           end;
    
    implementation
    
    &#123; tpf_simpleplayer &#125;
    
    constructor tpf_simpleplayer.create;
    begin
      fdjx&#58;= nil;
      ftm&#58;= nil;
    
      fwidth&#58;= 32;
      fheight&#58;= 64;
    
      fstretch_x&#58;= 1;
      fstretch_y&#58;= 1;
    end;
    
    procedure tpf_simpleplayer.render;
    begin
      if fdjx= nil then exit;
      if ftm= nil then exit;
    
      if ftm.djxtl.Find&#40;fnameintl&#41;<> nil then begin
        //player stretchen
        &#123;
        ftm.djxtl.Find&#40;fnameintl&#41;.Draw4col&#40;
                                           &#40;fx* ftile_width&#41;* fstretch_x,
                                           &#40;fy* ftile_height&#41;* fstretch_y,
                                           &#40;fx* ftile_width&#41;* fstretch_x+ ftile_width* fstretch_x,
                                           &#40;fy* ftile_height&#41;* fstretch_y,
                                           &#40;fx* ftile_width&#41;* fstretch_x+ ftile_width* fstretch_x,
                                           &#40;fy* ftile_height&#41;* fstretch_y+ ftile_height* fstretch_y,
                                           &#40;fx* ftile_width&#41;* fstretch_x,
                                           &#40;fy* ftile_height&#41;* fstretch_y+ ftile_height* fstretch_y,
                                           djxcolor&#40;clwhIte&#41;,
                                           djxcolor&#40;clwhIte&#41;,
                                           djxcolor&#40;clwhIte&#41;,
                                           djxcolor&#40;clwhIte&#41;
                                          &#41;;
         &#125;                                 
        ftm.djxtl.Find&#40;fnameintl&#41;.Draw4col&#40;
                                           &#40;fpos_x- fwidth/ 2&#41;* fstretch_x,
                                           &#40;fpos_y- fheight/ 2&#41;* fstretch_y,
                                           &#40;fpos_x+ fwidth/ 2&#41;* fstretch_x,
                                           &#40;fpos_y- fheight/ 2&#41;* fstretch_y,
                                           &#40;fpos_x+ fwidth/ 2&#41;* fstretch_x,
                                           &#40;fpos_y+ fheight/ 2&#41;* fstretch_y,
                                           &#40;fpos_x- fwidth/ 2&#41;* fstretch_x,
                                           &#40;fpos_y+ fheight/ 2&#41;* fstretch_y,
                                           djxcolor&#40;clwhIte&#41;,
                                           djxcolor&#40;clwhIte&#41;,
                                           djxcolor&#40;clwhIte&#41;,
                                           djxcolor&#40;clwhIte&#41;
                                          &#41;;
    
        //kreuz auf fpos
        fdjx.Primitives2D.Line&#40;fpos_x- 5, fpos_y- 5, fpos_x+ 5, fpos_y+ 5, djxcolor&#40;clwhite&#41;&#41;;
        fdjx.Primitives2D.Line&#40;fpos_x+ 5, fpos_y- 5, fpos_x- 5, fpos_y+ 5, djxcolor&#40;clwhite&#41;&#41;;
      end;
    end;
    
    procedure tpf_simpleplayer.setdjx&#40;const value&#58; tdanjetx&#41;;
    begin
      fdjx&#58;= value;
    end;
    
    procedure tpf_simpleplayer.setnameintl&#40;const value&#58; string&#41;;
    begin
      fnameintl&#58;= value;
    end;
    
    procedure tpf_simpleplayer.setpos_x&#40;const value&#58; single&#41;;
    begin
      fpos_x&#58;= value;
    end;
    
    procedure tpf_simpleplayer.setpos_y&#40;const value&#58; single&#41;;
    begin
      fpos_y&#58;= value;
    end;
    
    procedure tpf_simpleplayer.setstretch_x&#40;const value&#58; single&#41;;
    begin
      fstretch_x&#58;= value;
    end;
    
    procedure tpf_simpleplayer.setstretch_y&#40;const value&#58; single&#41;;
    begin
      fstretch_y&#58;= value;
    end;
    
    procedure tpf_simpleplayer.settm&#40;const value&#58; tdxtexturemanager&#41;;
    begin
      ftm&#58;= value;
    end;
    
    procedure tpf_simpleplayer.setx&#40;const value&#58; integer&#41;;
    begin
      fx&#58;= value;
    end;
    
    procedure tpf_simpleplayer.sety&#40;const value&#58; integer&#41;;
    begin
      fy&#58;= value;
    end;
    
    end.

  10. #30

    Making a platform game - few questions

    unit '__pf_simplemap'

    Code:
    unit __pf_simplemap;
    
    // http&#58;//pascalgamedevelopment.com/viewtopic.php?p=45392#45392  //platformer threat
    // http&#58;//www.tonypa.pri.ee/tbw/start.html  //tile based games tutorial
    // http&#58;//www.gamedev.net/reference/articles/article694.asp  //gravity
    
    interface
    
    uses Windows,
         Messages,
         SysUtils,
         Variants,
         Classes,
         Graphics,
         Controls,
         Forms,
         Dialogs,
         DJXTimer,
         DJX,
         ExtCtrls,
         djxclasses,
         d3dx9,
         StdCtrls,
         DJXFonts,
         ComCtrls,
         djxlandscape,
         djxtextures,
         Direct3D9,
         djxrender,
         djxmeshes,
         DJXMaterials,
         DJXLights,
         __dxtexturemanager;
    
    type trectile= record
                     idx&#58; integer;
                     walkable&#58; boolean;
                   end;
    
    type tarrrectile= array of array of trectile;
    
    type tpf_simplemap= class
                          public
                            constructor create;
    
                            procedure render;
    
                            procedure loadfromtextfile&#40;filename&#58; string&#41;;
                          private
                            fdjx&#58; tdanjetx;
                            ftm&#58; tdxtexturemanager;
                            fnameintl&#58; string;
    
                            fpattern&#58; tarrrectile;
    
                            ftile_width,
                            ftile_height&#58; integer;
                            
                            fstretch_x,
                            fstretch_y&#58; single;
    
                            fwidth,
                            fheight&#58; integer;
    
                            procedure setdjx&#40;const value&#58; tdanjetx&#41;;
                            procedure settm&#40;const value&#58; tdxtexturemanager&#41;;
                            procedure setnameintl&#40;const value&#58; string&#41;;
                            procedure setstretch_x&#40;const value&#58; single&#41;;
                            procedure setstretch_y&#40;const value&#58; single&#41;;
    
                            procedure pattern_fill;
    
                          published
                            property djx&#58; tdanjetx read fdjx write setdjx;
                            property texturemanager&#58; tdxtexturemanager read ftm write settm;
                            property nameintl&#58; string read fnameintl write setnameintl;
                            property stretch_x&#58; single read fstretch_x write setstretch_x;
                            property stretch_y&#58; single read fstretch_y write setstretch_y;
                            property tile_width&#58; integer read ftile_width;
                            property tile_height&#58; integer read ftile_height;
                            property pattern&#58; tarrrectile read fpattern;
                            property width&#58; integer read fwidth;
                            property height&#58; integer read fheight;
                        end;
    
    implementation
    
    &#123; tpf_simplemap &#125;
    
    constructor tpf_simplemap.create;
    begin
      fdjx&#58;= nil;
      ftm&#58;= nil;
    
      ftile_width&#58;= 32;
      ftile_height&#58;= 32;
    
      fstretch_x&#58;= 1;
      fstretch_y&#58;= 1;
    
      fwidth&#58;= 0;
      fheight&#58;= 0;
    
      //pattern_fill;
    end;
    
    procedure tpf_simplemap.loadfromtextfile&#40;filename&#58; string&#41;;
    var sl_file&#58; tstringlist;
        s_zeile&#58; string;
        x,
        y,
        i,
        j,
        h,
        hi&#58; integer;
    begin
      //pattern aus einer einfachen textdatei laden
      setlength&#40;fpattern, 0&#41;;
    
      if fileexists&#40;filename&#41; then begin
        sl_file&#58;= tstringlist.create;
    
        sl_file.LoadFromFile&#40;filename&#41;;
    
        if sl_file.Count> 0 then begin
          for i&#58;= 0 to sl_file.count- 1 do begin
            s_zeile&#58;= trim&#40;sl_file&#91;i&#93;&#41;;
    
            if s_zeile= '' then continue;
    
            setlength&#40;fpattern, length&#40;fpattern&#41;+ 1&#41;;
            h&#58;= high&#40;fpattern&#41;;
            setlength&#40;fpattern&#91;h&#93;, 0&#41;;
            for j&#58;= 1 to length&#40;s_zeile&#41; do begin
              setlength&#40;fpattern&#91;h&#93;, length&#40;fpattern&#91;h&#93;&#41;+ 1&#41;;
              hi&#58;= high&#40;fpattern&#91;h&#93;&#41;;
    
              if s_zeile&#91;j&#93;= '1' then begin
                fpattern&#91;h, hi&#93;.idx&#58;= 1;
                fpattern&#91;h, hi&#93;.walkable&#58;= false;
              end
              else begin
                fpattern&#91;h, hi&#93;.idx&#58;= 0;
                fpattern&#91;h, hi&#93;.walkable&#58;= true;
              end;
            end;
          end;
        end;
    
        sl_file.free;
      end;
    
      fheight&#58;= length&#40;fpattern&#41;;
      fwidth&#58;= length&#40;fpattern&#91;0&#93;&#41;;
    end;
    
    procedure tpf_simplemap.pattern_fill;
    var x,
        y&#58; integer;
    begin
      //pattern zuf?§llig bef?ºllen
      setlength&#40;fpattern, 20&#41;;
      for x&#58;= low&#40;fpattern&#41; to high&#40;fpattern&#41; do begin
        setlength&#40;fpattern&#91;x&#93;, 15&#41;;
        for y&#58;= low&#40;fpattern&#91;x&#93;&#41; to high&#40;fpattern&#91;x&#93;&#41; do begin
          fpattern&#91;x, y&#93;.idx&#58;= 0;
          fpattern&#91;x, y&#93;.walkable&#58;= true;
          randomize;
          if random&#40;100&#41;> 90 then begin
            fpattern&#91;x, y&#93;.idx&#58;= 1;
            fpattern&#91;x, y&#93;.walkable&#58;= false;
          end;
        end;
      end;
    end;
    
    procedure tpf_simplemap.render;
    var x,
        y&#58; integer;
    begin
      if fdjx= nil then exit;
      if ftm= nil then exit;
    
      for y&#58;= low&#40;fpattern&#41; to high&#40;fpattern&#41; do begin
        for x&#58;= low&#40;fpattern&#91;y&#93;&#41; to high&#40;fpattern&#91;y&#93;&#41; do begin
          if fpattern&#91;y, x&#93;.idx= 1 then begin
    
            if ftm.djxtl.Find&#40;fnameintl&#41;<> nil then begin
              //tiles stretchen
              ftm.djxtl.Find&#40;fnameintl&#41;.Draw4col&#40;
                                                 &#40;x* ftile_width&#41;* fstretch_x,
                                                 &#40;y* ftile_height&#41;* fstretch_y,
                                                 &#40;x* ftile_width&#41;* fstretch_x+ ftile_width* fstretch_x,
                                                 &#40;y* ftile_height&#41;* fstretch_y,
                                                 &#40;x* ftile_width&#41;* fstretch_x+ ftile_width* fstretch_x,
                                                 &#40;y* ftile_height&#41;* fstretch_y+ ftile_height* fstretch_y,
                                                 &#40;x* ftile_width&#41;* fstretch_x,
                                                 &#40;y* ftile_height&#41;* fstretch_y+ ftile_height* fstretch_y,
                                                 djxcolor&#40;clwhIte&#41;,
                                                 djxcolor&#40;clwhIte&#41;,
                                                 djxcolor&#40;clwhIte&#41;,
                                                 djxcolor&#40;clwhIte&#41;
                                                &#41;;
            end;
    
          end;
        end;
      end;
    end;
    
    procedure tpf_simplemap.setdjx&#40;const value&#58; tdanjetx&#41;;
    begin
      fdjx&#58;= value;
    end;
    
    procedure tpf_simplemap.setnameintl&#40;const value&#58; string&#41;;
    begin
      fnameintl&#58;= value;
    end;
    
    procedure tpf_simplemap.setstretch_x&#40;const value&#58; single&#41;;
    begin
      fstretch_x&#58;= value;
    end;
    
    procedure tpf_simplemap.setstretch_y&#40;const value&#58; single&#41;;
    begin
      fstretch_y&#58;= value;
    end;
    
    procedure tpf_simplemap.settm&#40;const value&#58; tdxtexturemanager&#41;;
    begin
      ftm&#58;= value;
    end;
    
    end.

Page 3 of 5 FirstFirst 12345 LastLast

Bookmarks

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •  
Comodo SSL