usprite.pas

泡泡游戏---实验阶段

       //此后面要加入设置动画参数程序;
       if FExtendPower=0 then
       begin
         AnimStart:=5;
         Exit;
       end;
       AnimStart:=1;
  
  
     end;
   3:begin
       SX:=iSX-1;
       SY:=iSY;
       //此后面要加入设置动画参数程序;
       if FExtendPower=0 then
       begin
         AnimStart:=7;
         Exit;
       end;
       AnimStart:=2;
     end;
   4:begin
       SX:=iSX;
       SY:=iSY+1;
       //此后面要加入设置动画参数程序;
       if FExtendPower=0 then
       begin
         AnimStart:=4;
         Exit;
       end;
       AnimStart:=1;
  
     end;
   end;//endcase
end;

function TExtendFireSprite.MakeSelfDes: string;
begin
  Result := inherited MakeSelfDes;
end;

procedure TExtendFireSprite.SetDXISL(Value: TDXImageList);
begin
  inherited SetDXISL(Value);
  Image:=Value.Items.Find('Fire');
  Width:=Image.Width;
  Height:=Image.Height;
  AnimLooped:=True;
  AnimSpeed:=0.1;
  AnimCount:=1;
end;

{
*********************************** TGameMap ***********************************
}
constructor TGameMap.Create;
begin
  inherited Create;
  FTileSize:=20;
end;

procedure TGameMap.ClearSpriteAt(const iSX,iSY:integer);
begin
  FSpriteAtXY[iSX,iSY]:=nil;
end;

function TGameMap.GetBombAt(const iSX,iSY:integer): TBombSprite;
begin
  Result:=nil;
  if FSpriteAtXY[iSX,iSY] is TBombSprite then
  begin
    Result:=TBombSprite(FSpriteAtXY[iSX,iSY]);
  end;
end;

function TGameMap.MapPos(const Pos:TPos): TPos;
begin
  Result.X:=Pos.X div FTileSize;
  if (Pos.X mod FTileSize) >= (FTileSize div 2) then Inc(Result.X);
  Result.Y:=Pos.Y div FTileSize;
  if (Pos.Y mod FTileSize)>=(FTileSize div 2)  then Inc(Result.Y);
end;

function TGameMap.SetSpriteAt(const iSX,iSY:integer;const oSprite:TGameSprite):
        Boolean;
var
  oTmpSprite: TGameSprite;
begin
  Result:=True;
  oTmpSprite:=GetBombAt(iSX,iSY);
  if Assigned(oTmpSprite) then
  begin
    Result:=False;
    Exit;
  end;
  FSpriteAtXY[iSX,iSY]:=oSprite;
end;

procedure TGameMap.SetTileSize(Value: Integer);
begin
  FTileSize:=Value;
  FWidth:=FXTiles*FTileSize;
  FHeight:=FYTiles*FTileSize;
end;

procedure TGameMap.SetXYTiles(const iXTiles,iYTiles:integer);
begin
  FXTiles:=iXTiles;
  FYTiles:=iYTiles;
  SetLength(FSpriteAtXY,FXTiles,FYTiles);
  FWidth:=FXTiles*FTileSize;
  FHeight:=FYTiles*FTileSize;
end;

function TGameMap.UnMapPos(const Pos:TPos): TPos;
begin
  Result.X:=Pos.X*FTileSize;
  Result.Y:=Pos.Y*FTileSize;
end;

{
***************************** TActiveSpriteManager *****************************
}
constructor TActiveSpriteManager.Create;
begin
  inherited Create;
  FFreeHeadIndex:=-1;
  FUsedHeadIndex:=-1;
  FUsedRearIndex:=-1;
  FTmpList:=TList.Create;
end;

destructor TActiveSpriteManager.Destroy;
begin
  inherited Destroy;
  FTmpList.Free;
end;

function TActiveSpriteManager.AddSprite(const oSprite:TGameSprite): Boolean;
var
  iTmpIndex: Integer;
begin
  Result:=True;
  if FFreeHeadIndex=-1 then
  begin
    Result:=False;
    Exit;
  end;
  Inc(FUsedCount);
  FSpriteLink[FFreeHeadIndex].Sprite:=oSprite;
  oSprite.QInActive:=FFreeHeadIndex;
  iTmpIndex:=FSpriteLink[FFreeHeadIndex].Next;
  
  FSpriteLink[oSprite.QInActive].Next:=FUsedHeadIndex;
  
  FSpriteLink[iTmpIndex].Prior:=-1;
  if FUsedHeadIndex>-1 then
  begin
   FSpriteLink[FUsedHeadIndex].Prior:=oSprite.QInActive;
  end;
  if FUsedRearIndex=-1 then FUsedRearIndex:=oSprite.QInActive;
  
  FUsedHeadIndex:=oSprite.QInActive;
  FFreeHeadIndex:=iTmpIndex;
  
  if oSprite is TBombSprite then
  begin
    FLinkNum:=LinkExplodeProccess(oSprite.QInActive);
  end;
end;

procedure TActiveSpriteManager.DoAct;
var
  iTempIndex,iTempIndex1: Integer;
begin
  iTempIndex:=FUsedHeadIndex;
  while iTempIndex<>-1 do
  begin
    iTempIndex1:=FSpriteLink[iTempIndex].Next;
    FSpriteLink[iTempIndex].Sprite.Act;
    iTempIndex:=iTempIndex1;
  end;
end;

function TActiveSpriteManager.LinkExplodeProccess(const
        oBombQInActive:integer): Integer;
var
  index: Integer;
  i: Integer;
  iTmpActivateTime: Integer;
  oTmpBomb: TBombSprite;
begin
  Result:=0;
  FTmpList.Clear;
  index:=FUsedRearIndex;
  while index<>-1 do
  begin
    if ((FSpriteLink[index].Sprite is TBombSprite)and(index<>oBombQInActive)) then
    begin
      if FSpriteLink[oBombQInACtive].Sprite.IsLinkWith
         (FSpriteLink[index].Sprite)
  
      then
      begin
        Inc(Result);
  
        if FSpriteLink[oBombQInACtive].Sprite.ActivateTime>
           FSpriteLink[index].Sprite.ActivateTime then
        begin
          FSpriteLink[oBombQInACtive].Sprite.ActivateTime:=
          FSpriteLink[index].Sprite.ActivateTime;
          FTmpList.Insert(0,FSpriteLink[index].Sprite);
          continue;
        end ;
        if FSpriteLink[oBombQInACtive].Sprite.ActivateTime<
           FSpriteLink[index].Sprite.ActivateTime then
        begin
          FTmpList.Add(FSpriteLink[index].Sprite);
        end;
      end;
    end;
    index:=FSpriteLink[index].Prior;
  end;
  
  for i:=1 to FTmpList.Count-1 do
  begin
    iTmpActivateTime:=TBombSprite(FTmpList.Items[i]).ActivateTime;
    index:=FUsedRearIndex;
    while index<>-1 do
    begin
      oTmpBomb:=TBombSprite(FSpriteLink[index].Sprite);
      if oTmpBomb.ActivateTime=iTmpActivateTime then
      begin
        oTmpBomb.ActivateTime:=FSpriteLink[oBombQInACtive].Sprite.ActivateTime;
      end;
      index:=FSpriteLink[index].Prior;
    end;
  end;
end;

procedure TActiveSpriteManager.MakeSpace(const iSpace:integer);
var
  i: Integer;
begin
  if iSpace<=0 then Exit;
  SetLength(FSpriteLink,iSpace);
  for i:=0 to iSpace-1 do
  begin
   if not(i=iSpace-1) then
   begin
     FSpriteLink[i].Next:=i+1;
   end else FSpriteLink[i].Next:=-1;
  end;
  for i:=iSpace-1 downto 0  do
  begin
   if not(i=0) then
   begin
     FSpriteLink[i].Prior:=i-1;
   end else FSpriteLink[i].Prior:=-1;
  end;
  FFreeHeadIndex:=0;
end;

procedure TActiveSpriteManager.ReleaseSprite(const oSprite:TGameSprite);
var
  iTempIndex: Integer;
  iTempUsedNext: Integer;
  iTempUsedPrior: Integer;
begin
  Dec(FUsedCount);
    iTempUsedNext:=FSpriteLink[OSprite.QInActive].Next;
    iTempUsedPrior:=FSpriteLink[OSprite.QInActive].Prior;
    ////////////处理空闲链/////////////////////
    iTempIndex:=FFreeHeadIndex;
    FFreeHeadIndex:=OSprite.QInActive;
    FSpriteLink[FFreeHeadIndex].Next:=iTempIndex;
    FSpriteLink[iTempIndex].Prior:=FFreeHeadIndex;
    FSpriteLink[FFreeHeadIndex].Prior:=-1;
    //////////////处理使用链///////////////////////////
  
    if ((iTempUsedPrior>-1) and (iTempUsedNext>-1))then
    begin
      FSpriteLink[iTempUsedPrior].Next:=iTempUsedNext;
      FSpriteLink[iTempUsedNext].Prior:=iTempUsedPrior;
      Exit;
    end;
    if ((iTempUsedPrior=-1)and(iTempUsedNext>-1))then
    begin
      FUsedHeadIndex:=iTempUsedNext;
      FSpriteLink[iTempUsedNext].Prior:=-1;
      Exit;
    end;
    if ((iTempUsedPrior>-1)and(iTempUsedNext=-1))then
    begin
      FUsedRearIndex:=iTempUsedPrior;
      FSpriteLink[iTempUsedPrior].Next:=-1;
  
      Exit;
    end;
    if ((iTempUsedPrior=-1)and(iTempUsedNext=-1))then
    begin
      FUsedHeadIndex:=-1;
    end;
end;

{
******************************* TGameSpritePool ********************************
}
destructor TGameSpritePool.Destroy;
var
  i: Integer;
begin
  inherited Destroy;
  for i:=0 to FSpriteCount-1 do
  begin
    if Assigned(FSpriteItems[i].Sprite) then
    begin
     if not (FSPriteItems[i].Sprite.ActivateTime>0) then
     begin
       FSpriteItems[i].Sprite.Parent.Add(FSpriteItems[i].Sprite);
     end;
     FSpriteItems[i].Sprite.Free;
    end;
  end;
end;

function TGameSpritePool.FindOutUseDes(const strClassID:string): Integer;
var
  i: Integer;
begin
  Result:=-1;
  for i:=0 to FClassCount-1 do
  begin
    if FUseDesList[i].ClassID=strClassID then
    begin
      Result:=i;
      Exit;
    end;
  end;
end;

function TGameSpritePool.GetSprite(const strClassID:string): TGameSprite;
var
  index: Integer;
  index2: Integer;
begin
  Result:=nil;
  index:=FindOutUseDes(strClassID);
  if (index=-1) then Exit;
  if FUseDesList[index].HeadIndex=-1 then Exit;
  /////////////////////////////////////
  index2:=FUseDesList[index].HeadIndex;
  Result:=FSpriteItems[index2].Sprite;
  
  //////////////////////////////////
  Inc(FUseDesList[index].UsedCount);
  FUseDesList[index].HeadIndex:=FSpriteItems[index2].Next;
end;

procedure TGameSpritePool.ResisterSprite(const oSprite: TGameSprite;const
        iAmount:integer);
var
  i: Integer;
  index: Integer;
  index2: Integer;
begin
  if not (iAmount>0) then Exit;
  SetLength(FSpriteItems,FSpriteCount+iAmount);
  index:=FindOutUseDes(oSprite.ClassName);
  
  /////////////////////////
  for i:=0 to iAmount-1 do
  begin
   FSpriteItems[FSpriteCount+i].Sprite:=oSprite.Clone;
   FSpriteItems[FSpriteCount+i].Sprite.QInPool:=FSpriteCount+i;
  end;
  
  for i:=0 to iAmount-1 do
   begin
     if i<(iAmount-1) then
     begin
       FSpriteItems[FSpriteCount+i].Next:=FSpriteCount+i+1;
     end else
     begin
       FSpriteItems[FSpriteCount+i].Next:=-1;
     end;
   end;
   ///////////////////////////////
  
  if index>-1 then//若能在池中找到该类精灵已有的注册条目
  begin
   index2:=FUseDesList[index].HeadIndex;
   FSpriteItems[FSpriteCount+iAmount-1].Next:=index2;
  
   FUseDesList[index].HeadIndex:=FSpriteCount;
   Inc(FUseDesList[index].Count,iAmount);
   Inc(FSpriteCount,iAmount);
   Exit;
  end;
  ////找不到时
  Inc(FClassCount);
  SetLength(FUseDesList,FClassCount);
  FUseDesList[FClassCount-1].HeadIndex:=FSpriteCount;
  FUseDesList[FClassCount-1].ClassID:=oSprite.ClassName;
  Inc(FSpriteCount,iAmount);
  FUseDesList[FClassCount-1].Count:=iAmount;
end;

procedure TGameSpritePool.ReturnSprite(const oSprite: TGameSprite);
var
  index,index2: Integer;
begin
  index:=FindOutUseDes(oSprite.ClassName);
  if (index=-1) then Exit;
  Dec(FUseDesList[index].UsedCount);
  /////////////////////////////////////
  index2:=FUseDesList[index].HeadIndex;
  
  FUseDesList[index].HeadIndex:=oSprite.QInPool;
  
  FSpriteItems[oSprite.QInPool].Next:=index2;
end;

{
******************************** TASMSingleton *********************************
}
class procedure TASMSingleton.FreeASM;
begin
  if Assigned(g_oASM) then
  begin
    g_oASM.Free;
  
  end;
end;

class function TASMSingleton.GetASM: TActiveSpriteManager;
begin
  if not Assigned(g_oASM) then
  begin
    g_oASM:=TActiveSpriteManager.Create;
  
  end;
  Result:=g_oASM;
end;

{
******************************** TPoolSingleton ********************************
}
class procedure TPoolSingleton.FreePool;
begin
  if Assigned(g_oSpritePool) then
  begin
    g_oSpritePool.Free;
  
  end;
end;

class function TPoolSingleton.GetSpritePool: TGameSpritePool;
begin
  if not Assigned(g_oSpritePool) then
  begin
    g_oSpritePool:=TGameSpritePool.Create;
  
  end;
  Result:=g_oSpritePool;
end;


end.