meta.pas

一款RPG游戏的引擎可以自己制作一款RPG游戏的引擎可以自己制作

end;

procedure TMeta.Reset;
var i : integer;
begin
  for i := 0 to length(Level) do
    setlength(Level[i].Images,0);
  setlength(Level,0);
end;

procedure TMeta.ReSize(L, I: integer);
begin
  if (Length(Level)<=L) then setlength(Level,L+1);
  if (length(level[l].Images)<=I) then setlength(Level[l].IMages,I+1);
end;

function TMeta.GetRandomImage(Layer : integer): Integer;
begin
  if (length(level)>=Layer) then
    result := random(Length(level[Layer].Images))
  else
    Result := -1;
end;

procedure TMeta.GetRandomNeighbors(Layer, Image: integer; var nw, ne, sw,
  se: integer);
var i : Integer;
begin
  if (Image = -1) then image := 0;
  i := Length(level[layer].Images[image].nw);
  if (i>0) then
    nw := Level[Layer].Images[Image].nw[Random(i)]
  else nw := -1;
  i := Length(level[layer].Images[image].ne);
  if (i>0) then
    ne := Level[Layer].Images[Image].ne[Random(i)]
  else ne := -1;
  i := Length(level[layer].Images[image].sw);
  if (i>0) then
    sw := Level[Layer].Images[Image].sw[Random(i)]
  else sw := -1;
  i := Length(level[layer].Images[image].se);
  if (i>0) then
    se := Level[Layer].Images[Image].se[Random(i)]
  else se := -1;
end;

function TMeta.IsCompatible(L, I, nw, ne, sw, se: Integer): Boolean;
var n,j,k,p : integer;
begin
  Result := true;
  if (I=-1) then Exit;
  for n := 0 to length(level[l].images[i].se)-1 do
  begin
    if (se=-1) or (se = level[l].images[i].se[n]) then
    begin
      for j := 0 to length(level[l].Images[i].nw)-1 do
      if (nw=-1) or (nw = Level[l].Images[i].nw[j]) then
      begin
        for k := 0 to length(level[l].Images[i].sw)-1 do
        begin
          if (sw = -1) or (sw = Level[l].Images[i].sw[k]) then
          begin
            for p := 0 to length(Level[l].Images[i].se)-1 do
              if (se=-1) or (se = Level[l].Images[i].se[p]) then
                exit;
          end;
        end;
      end;
    end;
  end;
  result := false;
end;

function TMeta.GetCompatible(L, nw, ne, sw, se: Integer): integer;
var i : integer;
begin
  for i := 0 to Length(level[L].Images)-1 do
  begin
    if IsCompatible(L,i,nw,ne,sw,se) then
    begin
      Result := i;
      Exit;
    end;
  end;
  Result := -1;
  Exit;
{  if (nw<>-1) then
  begin
    for n := 0 to length(level[l].images[nw].se)-1 do  // search 1 direction for and check on all possible
    begin
      result := Level[L].Images[nw].se[n];
      if (IsCompatible(L,result,nw,ne,sw,se)) then Exit;  // directions
    end
  end
  else
  if (sw<>-1) then
  begin
    for n := 0 to length(level[l].images[sw].ne)-1 do  // search 1 direction for and check on all possible
    begin
      result := Level[L].Images[sw].ne[n];
      if (IsCompatible(L,result,nw,ne,sw,se)) then Exit;  // directions
    end
  end
  else
  if (ne<>-1) then
  begin
    for n := 0 to length(level[l].images[ne].sw)-1 do  // search 1 direction for and check on all possible
    begin
      result := Level[L].Images[ne].sw[n];
      if (IsCompatible(L,result,nw,ne,sw,se)) then Exit;  // directions
    end
  end
  else
  if (se<>-1) then
  begin
    for n := 0 to length(level[l].images[se].nw)-1 do  // search 1 direction for and check on all possible
    begin
      result := Level[L].Images[se].nw[n];
      if (IsCompatible(L,result,nw,ne,sw,se)) then Exit;  // directions
    end
  end;

  Result := -1;}
end;

function TMeta.GetCompatibleNE(L, ne: integer): integer;
begin
  if (ne<0) then Result := 0
  else
    result := Level[L].Images[ne].ne[random(length(level[l].Images[ne].ne)-1)];
end;

function TMeta.GetCompatibleNW(L, nw: integer): integer;
begin
  if (nw<0) then Result := 0
  else
  result := Level[L].Images[nw].nw[random(length(level[l].Images[nw].nw)-1)];
end;

function TMeta.GetCompatibleSE(L, se: integer): integer;
begin
  if (se<0) then Result := 0
  else
  result := Level[L].Images[se].se[random(length(level[l].Images[se].se)-1)];
end;

function TMeta.GetCompatibleSW(L, sw: integer): integer;
begin
  if (sw<0) then Result := 0
  else
  result := Level[L].Images[sw].sw[random(length(level[l].Images[sw].sw)-1)];
end;

function TMeta.IsCompatibleNE(L, I1,I2: Integer): Boolean;
var p : integer;
begin
  result := true;
  for p := 0 to length(Level[L].Images[I1].ne)-1 do
    if (Level[L].Images[I1].NE[p]=I2) then exit;
  result := false;
end;

function TMeta.IsCompatibleNW(L, I1, I2: Integer): Boolean;
var p : integer;
begin
  result := true;
  for p := 0 to length(Level[L].Images[I1].nw)-1 do
    if (Level[L].Images[I1].NW[p]=I2) then exit;
  result := false;
end;

function TMeta.IsCompatibleSE(L, I1, I2: Integer): Boolean;
var p : integer;
begin
  result := true;
  for p := 0 to length(Level[L].Images[I1].se)-1 do
    if (Level[L].Images[I1].SE[p]=I2) then exit;
  result := false;
end;

function TMeta.IsCompatibleSW(L, I1, I2: Integer): Boolean;
var p : integer;
begin
  result := true;
  for p := 0 to length(Level[L].Images[I1].sw)-1 do
    if (Level[L].Images[I1].sw[p]=I2) then exit;
  result := false;
end;

procedure TMeta.AddBelowNeighbor(L, I, Neighbor: Integer);
var j : integer;
begin
  Resize(L,i);
  with(Level[L].Images[i]) do
  begin
    for j := 0 to Length(below)-1 do
      if (Below[j] = Neighbor) then Exit;   // aready here
    j := Length(Below);
    SetLength(below,j+1);
    below[j] := Neighbor;
  end;
end;

procedure TMeta.CalculateHeights;                // this code is garbage
var l,i,j,h : Integer;
begin
  h := 0;
  for l := 0 to Length(Level)-1 do
      for i := 0 to Length(level[l].Images)-1 do
        Level[l].Images[i].Height := 0; // reset everybody

  for l := 0 to Length(Level)-1 do
  begin
      for i := 0 to Length(level[l].Images)-2 do
      begin
        if (level[l].Images[i].Height+1<i) then
          Level[l].Images[i].Height := h+1;
        h := Level[l].Images[i].Height+1;
        for j := i+1 to Length(level[l].images)-1 do
        begin

          if (Level[l].Images[i].Height=0) and (IsAnyCompatible(l,i,j)) then
              Level[l].Images[j].Height := h;
        end;
      end;
  end;
end;

function TMeta.GetCompatibleAbove(L, Below: Integer): Integer;
begin
  if (Below<0) then Result := random(length(level[l].images))
  else
    result := Level[L].Images[Below].below[random(length(level[l].Images[below].below)-1)];
end;

function TMeta.IsCompatibleBelow(L, I, Neighbor: Integer): Boolean;
var p : integer;
begin
  result := true;
  for p := 0 to length(Level[L].Images[I].Below)-1 do
    if (Level[L].Images[I].Below[p]=Neighbor) then exit;
  result := false;
end;

function TMeta.IsAnyCompatible(L, I,Neighbor: Integer): Boolean;
var p : integer;
begin
  result := true;
  for p := 0 to length(level[l].Images[i].nw)-1 do
    if (level[l].Images[i].nw[p] = Neighbor) then exit;
  for p := 0 to length(level[l].Images[i].ne)-1 do
    if (level[l].Images[i].ne[p] = Neighbor) then exit;
  for p := 0 to length(level[l].Images[i].sw)-1 do
    if (level[l].Images[i].sw[p] = Neighbor) then exit;
  for p := 0 to length(level[l].Images[i].se)-1 do
    if (level[l].Images[i].se[p] = Neighbor) then exit;
  result := false;
end;

function TMeta.GetHeight(L, I: Integer): Integer;
begin
  result := level[l].images[i].Height;
end;

end.