Show GameUnitClasses.pas syntax highlighted
//*******************************//
// //
// Strange Game Unit Classes //
// //
//******************//*******************************//*********************//
// //
// This unit is the part of a real time 3d space strategy engine //
// (www.federation.netfirms.com) //
// //
//**************************************************************************//
{
Author : Alexander Federyakov aka Da Stranger
Version : 0.001 ;-]
Date : 04 December '2005
License : You can use this unit ONLY for educational purposes. You cannot use
more than 10% of its code in your own personal projects. It cannot
be used for any commercial products.
Comments: This is the core of a 3d realtime space strategy game engine.
Much is still to be done...
Requirements: GLScene
Known Bugs and limitations: none
Contacts:
Web: http://www.sector-37.com
E-mail: datarget@mail.ru
ICQ: 293-963-070
Odigo: 8077227
}
unit GameUnitClasses;
interface
uses classes,windows,Strangeinifiles,VectorTypes,sysutils,Forms,ExtCtrls,controls,
dialogs,
GLFireFX,GLPerlinPFX,GLThorfx,GLObjects,GlScene,Graphics,
glmisc,vectorgeometry, GLVectorFileObjects, GLTexture,
GameConstants, StrangeMovementManager;
type
TUnitType = class;
TWeaponType = class;
TShieldType = class;
TEquipmentType = class;
TEngineType = class;
TRaceType = class;
TUnitClass = class;
//events
TRequestWeaponTypeEvent = procedure (Sender: TUnitType; const FileName: string;
var WeaponType: TWeaponType) of object;
TRequestShieldTypeEvent = procedure (Sender: TUnitType; const FileName: string;
var ShieldType: TShieldType) of object;
TRequestEquipmentTypeEvent = procedure (Sender: TUnitType; const
FileName: string; var EquipmentType: TEquipmentType) of object;
TRequestEngineTypeEvent = procedure (Sender: TUnitType; const FileName: string;
var EngineType: TEngineType) of object;
TRequestRaceTypeEvent = procedure (Sender:TObject; const FileName: string;
const index: byte; var RaceType: TRaceType; var MaxRaceTypes: byte) of
object;
TRequestUnitClassEvent = procedure (Sender: TObject; const FileName:string;
const index: byte; var UnitClass: TUnitClass; var MaxUnitClasses: byte)
of object;
TUnitTypeGeomStyle = (utgSmall, utgBig, utgFlat, utgHigh);
//Classes
TRaceType = class(TBaseGameIconObject)
protected
procedure LoadFromIni(ini: TStrangeIniFile; Section: string); override;
public
ID: Byte;
SomeSetting: Single;
end;
TRace = class(TBaseGameIconObject)
protected
procedure LoadFromIni(ini: TStrangeIniFile; Section: string); override;
public
onRequestRaceType: TRequestRaceTypeEvent;
RaceType: TRaceType;
UnitTypes: TStringList;
XPNeededForNextLevel: Single;
function GetUnitType(index: integer): TUnitType;
constructor Create;
destructor Destroy; override;
end;
TShieldSettings = class(TPrimitiveErrorHandlerClass)
public
DefenceBonus: Single;
HealthBonusAdd: Single;
HealthBonusMult: Single;
HealthRegenerateRateBonusAdd: Single;
HealthRegenerateRateBonusMult: Single;
ShieldsBonusAdd: Single;
ShieldsBonusMult: Single;
ShieldsRegenerateRateBonusAdd: Single;
ShieldsRegenerateRateBonusMult: Single;
procedure Assign(From: TShieldSettings);
procedure LoadFromIni(ini: TStrangeIniFile; Section:string);
end;
TWeaponSettings = class(TPrimitiveErrorHandlerClass)
public
Accuracy: Single;
BurstNumber: Single;
DeltaAngle: Single;
Power: Single;
RechargeInterval_big: Single;
RechargeInterval_small: Single;
WeaponRange: Single;
procedure Assign(From: TWeaponSettings);
procedure LoadFromIni(ini: TStrangeIniFile; Section: string);
procedure Multiply(From: TWeaponSettings);
end;
TDamageMatrix = class(TObject)
public
AgainstRace: array of single;
AgainstUnitClass: array of single;
procedure Assign(From: TDamageMatrix);
constructor Create;
destructor Destroy; override;
procedure LoadFromIni(ini: TStrangeIniFile; WeaponType: TWeaponType);
end;
TWeaponType = class(TBaseGameIconCostObject)
protected
procedure LoadFromIni(ini: TStrangeIniFile; Section: string); override;
public
ActorNear: TGLActor;
ActorMedium: TGLActor;
ActorFar: TGLActor;
TextureNear: TGLLibMaterial;
TextureMedium: TGLLibMaterial;
TextureFar: TGLLibMaterial;
DamageMatrix: TDamageMatrix;
EffectScale: Single;
EnableFire: Boolean;
EnablePerlin: Boolean;
EnableThor: Boolean;
FireManager: TGLFireFXManager;
LaserMode: Boolean;
MaxProjectileTime: Single;
ModelScale: Single;
WeaponLength: single;
onRequestRaceType: TRequestRaceTypeEvent;
onRequestUnitClass: TRequestUnitClassEvent;
PerlinManager: TGLPerlinPFXManager;
ProjectileFollowsTarget: Boolean;
ProjectileMovement: TStrangeMovement;
ProjectileScale: Single;
ShowWeaponModel: Boolean;
ThorManager: TGLThorFXManager;
TimeFiringLaser: Single;{ TODO 3 -oDa Stranger -cStandard : what the hell is that???? }
UseThorScript: Boolean;
WeaponCanTurn: Boolean;
WeaponSettings: TWeaponSettings;
WeaponTurnSpeed: Single;
procedure Assign(From: TWeaponType); reintroduce;
constructor Create;
destructor Destroy; override;
function GetDamageMatrixValue(UnitType: TUnitType): Single;
end;
TShieldType = class(TBaseGameIconCostObject)
protected
procedure LoadFromIni(ini: TStrangeIniFile; Section: string); override;
public
ShieldSettings: TShieldSettings;
procedure Assign(From: TShieldType); reintroduce;
constructor Create;
destructor Destroy; override;
end;
TEngineType = class(TBaseGameIconCostObject)
protected
procedure LoadFromIni(ini: TStrangeIniFile; Section: string); override;
public
MovementSettings: TStrangeMovement;
myEnginesSettings: TStrangeMemIniFile;
procedure Assign(From: TEngineType); reintroduce;
constructor Create;
destructor Destroy; override;
end;
TEquipmentType = class(TBaseGameIconCostObject)
protected
procedure LoadFromIni(ini: TStrangeIniFile; Section: string); override;
public
EquipmentSlotsRequired: Byte; //won't be used, probably...
MovementSettings: TStrangeMovement;
ShieldSettings: TShieldSettings;
WeaponSettings: TWeaponSettings;
ViewDistance: Single;
MovementScannerDistance: single;
procedure Assign(From: TEquipmentType); reintroduce;
constructor Create;
destructor Destroy; override;
end;
TUnitClass = class(TBaseGameIconObject)
protected
procedure LoadFromIni(ini: TStrangeIniFile; Section: string); override;
public
ID: Byte;
//XP upgrade parameters
MovementSettings: TStrangeMovement;
ShieldSettings: TShieldSettings;
ViewDistance: Single;
MovementScannerDistance: single;
WeaponSettings: TWeaponSettings;
constructor Create;
destructor Destroy; override;
end;
TUnitTypeWeaponParams = record
Position: TVector3f;
Direction: TVector3f;
UpVector: TVector3f;
TipPosition: TVector3f;
end;
TUnitTypeWeaponGroup = class(TPrimitiveErrorHandlerClass)
private
procedure LoadFromIni(ini: TStrangeIniFile; Section: string; UnitType: TUnitType);
public
CurrentWeapon: TWeaponType;
WeaponParams: array of TUnitTypeWeaponParams;
WeaponsAllowed: array of TWeaponType;
WeaponSettings: TWeaponSettings;
procedure Assign(From: TUnitTypeWeaponGroup);
constructor Create;
destructor Destroy; override;
function LastWeapon: Byte;
function WeaponNumber: Byte;
end;
TUnitType = class(TBaseGameIconCostObject)
protected
procedure LoadFromIni(ini: TStrangeIniFile; Section: string); override;
public
AnimationInterval: Integer;
SyncronizeWeaponAnimation : Boolean;
CurrentEngine: TEngineType;
CurrentEquipment: array of TEquipmentType;
CurrentShield: TShieldType;
Defence: single;
EnginesAllowed: array of TEngineType;
EquipmentAllowed: array of TEquipmentType;
EquipmentSlotsNumber: Byte;
ExplosionFileName: string;
HealthRegenerateRate: Single;
MaxHealth: Single;
MaxPeople: Single;
MaxShields: Single;
MovementSettings: TStrangeMovement;
OnRequestEngineType: TRequestEngineTypeEvent;
OnRequestEquipmentType: TRequestEquipmentTypeEvent;
OnRequestShieldType: TRequestShieldTypeEvent;
onRequestUnitClass: TRequestUnitClassEvent;
OnRequestWeaponType: TRequestWeaponTypeEvent;
PrimaryWeapon: Byte;
Race: TRace;
Scale: Single;
ShieldsAllowed: array of TShieldType;
ShieldsRegenerateRate: Single;
UnitClass: TUnitClass;
UsesAnimation: Boolean;
ViewDistance: Single;
MovementScannerDistance: single;
AttackDistance: single;
WeaponGroups: array of TUnitTypeWeaponGroup;
XPCost: Integer;
procedure Assign(From: TUnitType); reintroduce;
constructor Create;
destructor Destroy; override;
function LastWeaponGroup: Byte;
function WeaponGroupNumber: Byte;
end;
TPlayerUnitType = class(TUnitType) //filed after Init for each Player
public
ActorNear: TGLActor;
ActorMedium: TGLActor;
ActorFar: TGLActor;
TextureNear: array[0..2] of TGLLibMaterial;
TextureMedium: array[0..2] of TGLLibMaterial; //array for different damage levels
TextureFar: array[0..2] of TGLLibMaterial;
AnimationStream: TStream;
ExplosionMemIniFile: TStrangeMemIniFile;
EngineMemIniFile: TStrangeMemIniFile;
GeomStyle : TUnitTypeGeomStyle;
BoundingRadius: single;
BoundingDimentions: TVector3f;
BoundingWidth: single;
MinExtents: TVector3f; //filed after Init
MaxExtents: TVector3f; //filed after Init
procedure Assign(From: TPlayerUnitType); reintroduce;
procedure AssignFromUnitType(From: TUnitType);
constructor Create;
destructor Destroy; override;
end;
implementation
{ TUnitType }
{
********************************** TUnitType ***********************************
}
procedure TUnitType.Assign(From: TUnitType);
var
i: integer;
begin
inherited Assign(From);
AnimationInterval := From.AnimationInterval;
EquipmentSlotsNumber := From.EquipmentSlotsNumber;
Defence := From.Defence;
HealthRegenerateRate := From.HealthRegenerateRate;
MaxHealth := From.MaxHealth;
MaxPeople := From.MaxPeople;
MaxShields := From.MaxShields;
OnRequestEngineType := From.OnRequestEngineType;
OnRequestEquipmentType := From.OnRequestEquipmentType;
OnRequestShieldType := From.OnRequestShieldType;
onRequestUnitClass := From.onRequestUnitClass;
OnRequestWeaponType := From.OnRequestWeaponType;
PrimaryWeapon := From.PrimaryWeapon;
Race := From.Race;
Scale := From.Scale;
ShieldsRegenerateRate := From.ShieldsRegenerateRate;
UnitClass := From.UnitClass;
UsesAnimation := From.UsesAnimation;
SyncronizeWeaponAnimation := From.SyncronizeWeaponAnimation;
ViewDistance := From.ViewDistance;
MovementScannerDistance := From.MovementScannerDistance;
AttackDistance := From.AttackDistance;
XPCost := From.XPCost;
setlength(WeaponGroups, length(From.WeaponGroups));
if length(WeaponGroups) <> 0 then
for i := 0 to length(WeaponGroups) - 1 do
begin
WeaponGroups[i] := TUnitTypeWeaponGroup.Create;
WeaponGroups[i].Assign(From.WeaponGroups[i]);
end;
ShieldsAllowed := From.ShieldsAllowed;
EnginesAllowed := From.EnginesAllowed;
EquipmentAllowed := From.EquipmentAllowed;
CurrentEngine := From.CurrentEngine;
CurrentEquipment := From.CurrentEquipment;
CurrentShield := From.CurrentShield;
MovementSettings.StrangeAssign(From.MovementSettings, True, True);
ExplosionFileName := From.ExplosionFileName;
end;
constructor TUnitType.Create;
begin
inherited;
MovementSettings := TStrangeMovement.Create(nil);
end;
destructor TUnitType.Destroy;
begin
MovementSettings.Destroy;
inherited;
end;
function TUnitType.LastWeaponGroup: Byte;
begin
Result := length(WeaponGroups)-1;
end;
procedure TUnitType.LoadFromIni(ini: TStrangeIniFile; Section: string);
var
i: Byte;
tmp: string;
List: TStringList;
begin
inherited;
ViewDistance := ini.ReadFloat(str_GENERAL, str_VIEW_DISTANCE, ViewDistance);
MovementScannerDistance := ini.ReadFloat(str_GENERAL, str_MOVEMENT_SCANNER_DISTANCE, MovementScannerDistance);
AttackDistance := ini.ReadFloat(str_GENERAL, 'AttackDistance', AttackDistance);
XPCost := ini.ReadInteger(str_GENERAL,'XPCost',XPCost);
Defence := ini.ReadFloat(str_GENERAL,'Defence',Defence);
MaxPeople := ini.ReadFloat(str_GENERAL,'MaxPeople',Maxpeople);
MaxHealth := ini.ReadFloat(str_GENERAL,'MaxHealth',Maxhealth);
MaxShields := ini.ReadFloat(str_GENERAL,'MaxShields',MaxShields);
HealthRegenerateRate := ini.ReadFloat(str_GENERAL, 'HealthRegenerateRate', HealthRegenerateRate);
ShieldsRegenerateRate := ini.ReadFloat(str_GENERAL,'ShieldsRegenerateRate',ShieldsRegenerateRate);
Scale := ini.ReadFloat(str_GENERAL,'Scale',0);
UsesAnimation := ini.ReadBool(str_GENERAL,'UsesAnimation',False);
AnimationInterval := ini.ReadInteger(str_GENERAL,'AnimationInterval',0);
SyncronizeWeaponAnimation := ini.ReadBool(str_GENERAL,'SyncronizeWeaponAnimation',False);
EquipmentSlotsNumber := ini.ReadInteger(str_GENERAL,'EquipmentSlotsNumber',EquipmentSlotsNumber);
PrimaryWeapon := ini.ReadInteger(str_GENERAL,'PrimaryWeapon',PrimaryWeapon);
ExplosionFileName := ini.ReadString(str_GENERAL,'ExplosionFileName','');
tmp := ExtractFilePath(ini.FileName) + str_MOVEMENT_DSC;
if not FileExists(tmp) then
MakeError(str_ERROR_READING_FILE + tmp + str_IT_DOES_NOT_EXIST,8);
MovementSettings.LoadFromIniFile(tmp);
List := TSTringList.Create;
tmp := ini.ReadString(Section,str_UNIT_CLASS,'');
if Assigned(onRequestUnitClass) then onRequestUnitClass(self,tmp,0,UnitClass,i);
if UnitClass=nil then MakeError(str_UNIT_CLASS + ' "' + tmp + str_MENTIONED_IN_FILE + ini.FileName + str_NOT_FOUND ,7);
//Default stuff
tmp := ini.ReadString(str_GENERAL,str_DEFAULT_SHIELD,'');
if Assigned(OnRequestShieldType) then OnRequestShieldType(self,tmp,CurrentShield);
if CurrentShield=nil then MakeError(str_DEFAULT_SHIELD + ' "' + tmp + str_MENTIONED_IN_FILE + ini.FileName + str_NOT_FOUND ,7);
tmp := ini.ReadString(str_GENERAL,str_DEFAULT_ENGINE,'');
if Assigned(OnRequestEngineType) then OnRequestEngineType(self,tmp,CurrentEngine);
if CurrentEngine=nil then MakeError(str_DEFAULT_ENGINE + ' "' + tmp + str_MENTIONED_IN_FILE + ini.FileName + str_NOT_FOUND ,7);
if not ini.SectionExists(str_DEFAULT_EQUIPMENT) then
MakeError(str_ERROR_READING_SECTION + str_DEFAULT_EQUIPMENT + str_FROM_FILE + ini.FileName + str_IT_DOES_NOT_EXIST,7);
ini.ReadSection(str_DEFAULT_EQUIPMENT,List);
setlength(CurrentEquipment, List.Count);
for i := 0 to List.Count-1 do
begin
if Assigned(OnRequestEquipmentType) then OnRequestEquipmentType(self,List[i],CurrentEquipment[i]);
if CurrentEquipment[i]=nil then MakeError(str_DEFAULT_EQUIPMENT + ' "' + List[i] + str_MENTIONED_IN_FILE + ini.FileName + str_NOT_FOUND ,7);
end;
//stuff allowed
if not ini.SectionExists(str_SHIELDS_ALLOWED) then
MakeError(str_ERROR_READING_SECTION + str_SHIELDS_ALLOWED + str_FROM_FILE + ini.FileName + str_IT_DOES_NOT_EXIST,7);
ini.ReadSection(str_SHIELDS_ALLOWED,List);
setlength(ShieldsAllowed, List.Count);
for i := 0 to List.Count-1 do
begin
if Assigned(OnRequestShieldType) then OnRequestShieldType(self,List[i],ShieldsAllowed[i]);
if ShieldsAllowed[i]=nil then MakeError(str_SHIELDS_ALLOWED + ' "' + List[i] + str_MENTIONED_IN_FILE + ini.FileName + str_NOT_FOUND ,7);
end;
if not ini.SectionExists(str_ENGINES_ALLOWED) then
MakeError(str_ERROR_READING_SECTION + str_ENGINES_ALLOWED + str_FROM_FILE + ini.FileName + str_IT_DOES_NOT_EXIST,7);
ini.ReadSection(str_ENGINES_ALLOWED,List);
setlength(EnginesAllowed, List.Count);
for i := 0 to List.Count-1 do
begin
if Assigned(OnRequestEngineType) then OnRequestEngineType(self,List[i],EnginesAllowed[i]);
if EnginesAllowed[i]=nil then MakeError(str_ENGINES_ALLOWED + ' "' + List[i] + str_MENTIONED_IN_FILE + ini.FileName + str_NOT_FOUND ,7);
end;
if not ini.SectionExists(str_EQUIPMENT_ALLOWED) then
MakeError(str_ERROR_READING_SECTION + str_EQUIPMENT_ALLOWED + str_FROM_FILE + ini.FileName + str_IT_DOES_NOT_EXIST,7);
ini.ReadSection(str_EQUIPMENT_ALLOWED,List);
setlength(EquipmentAllowed, List.Count);
for i := 0 to List.Count-1 do
begin
if Assigned(OnRequestEquipmentType) then OnRequestEquipmentType(self,List[i],EquipmentAllowed[i]);
if EquipmentAllowed[i]=nil then MakeError(str_EQUIPMENT_ALLOWED + ' "' + List[i] + str_MENTIONED_IN_FILE + ini.FileName + str_NOT_FOUND ,7);
end;
setlength(WeaponGroups,ini.ReadInteger(str_GENERAL,'WeaponGroupNumber',0));
if length(WeaponGroups)<>0 then
for i := 0 to length(WeaponGroups)-1 do
begin
WeaponGroups[i] := TUnitTypeWeaponGroup.Create;
WeaponGroups[i].LoadFromIni(ini, 'WeaponGroup_' + inttostr(i+1) + '_',self);
end;
List.Free;
end;
function TUnitType.WeaponGroupNumber: Byte;
begin
Result := length(WeaponGroups);
end;
{ TShieldType }
{
********************************* TShieldType **********************************
}
procedure TShieldType.Assign(From: TShieldType);
begin
inherited Assign(From);
ShieldSettings.Assign(From.ShieldSettings);
end;
constructor TShieldType.Create;
begin
inherited;
ShieldSettings := TShieldSettings.Create;
end;
destructor TShieldType.Destroy;
begin
ShieldSettings.Destroy;
inherited;
end;
procedure TShieldType.LoadFromIni(ini: TStrangeIniFile; Section: string);
begin
inherited;
ShieldSettings.LoadFromIni(ini, str_SHIELD_SETTINGS);
end;
{ TEngineType }
{
********************************* TEngineType **********************************
}
procedure TEngineType.Assign(From: TEngineType);
var
Temp: TStringList;
begin
inherited Assign(From);
MovementSettings.StrangeAssign(From.MovementSettings, True, True);
Temp := TStringList.Create;
From.myEnginesSettings.GetStrings(Temp);
myEnginesSettings := TStrangeMemIniFile.Create('');
myEnginesSettings.SetStrings(Temp);
Temp.Destroy;
end;
constructor TEngineType.Create;
begin
inherited;
MovementSettings := TStrangeMovement.Create(nil);
end;
destructor TEngineType.Destroy;
begin
inherited;
MovementSettings.Destroy;
myEnginesSettings.Free;
end;
procedure TEngineType.LoadFromIni(ini: TStrangeIniFile; Section: string);
begin
inherited;
// MovementSettings.LoadSettingsFromFile(ini.FileName,str_MOVEMENT_SETTINGS,True);
myEnginesSettings := TStrangeMemIniFile.Create(ini.FileName);
end;
{ TEquipmentType }
{
******************************** TEquipmentType ********************************
}
procedure TEquipmentType.Assign(From: TEquipmentType);
begin
inherited Assign(From);
ViewDistance := From.ViewDistance;
MovementScannerDistance := From.MovementScannerDistance;
EquipmentSlotsRequired := From.EquipmentSlotsRequired;
MovementSettings.StrangeAssign(From.MovementSettings, True, True);
ShieldSettings.Assign(From.ShieldSettings);
WeaponSettings.Assign(From.WeaponSettings);
end;
constructor TEquipmentType.Create;
begin
inherited;
MovementSettings := TStrangeMovement.Create(nil);
ShieldSettings := TShieldSettings.Create;
WeaponSettings := TWeaponSettings.Create;
end;
destructor TEquipmentType.Destroy;
begin
inherited;
MovementSettings.Destroy;
ShieldSettings.Destroy;
WeaponSettings.Destroy;
end;
procedure TEquipmentType.LoadFromIni(ini: TStrangeIniFile; Section: string);
begin
inherited;
// MovementSettings.LoadsettingsFromFile(ini.FileName, str_MOVEMENT_SETTINGS, True);
ShieldSettings.LoadFromIni(ini, str_SHIELD_SETTINGS);
WeaponSettings.LoadFromIni(ini, str_WEAPON_SETTINGS);
ViewDistance := ini.ReadFloat(Section, str_VIEW_DISTANCE, ViewDistance);
MovementScannerDistance := ini.ReadFloat(Section, str_MOVEMENT_SCANNER_DISTANCE, MovementScannerDistance);
EquipmentSlotsRequired := ini.ReadInteger(Section,'EquipmentSlotsRequired', EquipmentSlotsRequired);
end;
{ TWeaponType }
{
********************************* TWeaponType **********************************
}
procedure TWeaponType.Assign(From: TWeaponType);
begin
inherited Assign(From);
EffectScale := From.EffectScale;
EnableFire := From.EnableFire;
EnablePerlin := From.EnablePerlin;
EnableThor := From.EnableThor;
LaserMode := From.LaserMode;
MaxProjectileTime := From.MaxProjectileTime;
ModelScale := From.ModelScale;
ProjectileFollowsTarget := From.ProjectileFollowsTarget;
ProjectileScale := From.ProjectileScale;
ShowWeaponModel := From.ShowWeaponModel;
WeaponLength := From.WeaponLength;
TimeFiringLaser := From.TimeFiringLaser;
UseThorScript := From.UseThorScript;
WeaponCanTurn := From.WeaponCanTurn;
WeaponTurnSpeed := From.WeaponTurnSpeed;
if EnableFire then
begin
FireManager := TGLFireFXManager.Create(nil);
FireManager.Assign(From.FireManager);
end;
if EnablePerlin then
begin
PerlinManager := TGLPerlinPFXManager.Create(nil);
PerlinManager.Assign(From.PerlinManager);
end;
if EnableThor then
begin
ThorManager := TGLthorFXmanager.Create(nil);
AssignThorFXManager(From.ThorManager, ThorManager);
end;
if not LaserMode then
begin
ProjectileMovement := TStrangeMovement.Create(nil);
ProjectileMovement.StrangeAssign(From.ProjectileMovement, True, True);
end;
ActorNear := From.ActorNear;
ActorMedium := From.ActorMedium;
ActorFar := From.ActorFar;
TextureNear := From.TextureNear;
TextureMedium := From.TextureMedium;
TextureFar := From.TextureFar;
WeaponSettings.Assign(From.WeaponSettings);
DamageMatrix.Assign(From.DamageMatrix);
end;
constructor TWeaponType.Create;
begin
inherited Create;
WeaponSettings := TWeaponSettings.Create;
DamageMatrix := TDamageMatrix.Create;
end;
destructor TWeaponType.Destroy;
begin
inherited;
ThorManager.Free;
PerlinManager.Free;
FireManager.Free;
WeaponSettings.Destroy;
DamageMatrix.Destroy;
ProjectileMovement.Free;
end;
function TWeaponType.GetDamageMatrixValue(UnitType: TUnitType): Single;
begin
Result := damagematrix.AgainstUnitClass[UnitType.UnitClass.ID] * damagematrix.AgainstRace[UnitType.Race.RaceType.ID];
end;
procedure TWeaponType.LoadFromIni(ini: TStrangeIniFile; Section: string);
begin
inherited LoadFromIni(ini, Section);
WeaponSettings.LoadFromIni(ini,'WeaponSettings');
DamageMatrix.LoadFromIni(ini,self);
LaserMode := ini.ReadBool(str_GENERAL,'LaserMode',False);
TimeFiringLaser := ini.Readfloat(str_GENERAL,'TimeFiringLaser',0);
MaxProjectileTime := ini.Readfloat(str_GENERAL,'MaxProjectileTime',0);
ProjectileFollowsTarget := ini.ReadBool(str_GENERAL,'ProjectileFollowsTarget',False);
ShowWeaponModel := ini.ReadBool(str_GENERAL,'ShowWeaponModel',False);
WeaponLength := ini.Readfloat(str_GENERAL,'WeaponLength',0);
EffectScale := ini.Readfloat(str_GENERAL,'EffectScale',0);
ModelScale := ini.Readfloat(str_GENERAL,'ModelScale',0);
ProjectileScale := ini.Readfloat(str_GENERAL,'ProjectileScale',0);
EnableThor := ini.ReadBool(str_GENERAL,'EnableThor',False);
EnablePerlin := ini.ReadBool(str_GENERAL,'EnablePerlin',False);
EnableFire := ini.ReadBool(str_GENERAL,'EnableFire',False);
UseThorScript := ini.ReadBool(str_GENERAL,'UseThorScript',False);
WeaponCanTurn := ini.ReadBool(str_GENERAL,'WeaponCanTurn',False);
WeaponTurnSpeed := ini.Readfloat(str_GENERAL,'WeaponTurnSpeed',0);
if not LaserMode then
begin
ProjectileMovement := TStrangeMovement.Create(nil);
// ProjectileMovement.LoadSettingsFromFile(ExtractFilePAth(ini.FileName) + str_MOVEMENT_DSC,str_GENERAL);
end;
if EnableThor then
begin
ThorManager := TGLthorFXmanager.Create(nil);
with ThorManager do
begin
Core := ini.ReadBool(str_THOR_MANAGER,'Core',False);
Glow := ini.ReadBool(str_THOR_MANAGER,'Glow',False);
GlowSize := ini.Readfloat(str_THOR_MANAGER,'GlowSize',0);
Maxpoints := ini.ReadInteger(str_THOR_MANAGER,'Maxpoints',0);
Vibrate := ini.Readfloat(str_THOR_MANAGER,'Vibrate',0);
Wildness := ini.Readfloat(str_THOR_MANAGER,'Wildness',0);
{ TODO 3 -oDa Stranger -cExtending Capabilities : Unknown BUG when I use InnerColor }
{
Innercolor.Red := ini.Readfloat(str_THOR_MANAGER,'ColorInnerRed',0);
Innercolor.Green := ini.Readfloat(str_THOR_MANAGER,'ColorInnerGreen',0);
Innercolor.Blue := ini.Readfloat(str_THOR_MANAGER,'ColorInnerBlue',0);
Innercolor.Alpha := ini.Readfloat(str_THOR_MANAGER,'ColorInnerAlpha',0);
}
Outercolor.Red := ini.Readfloat(str_THOR_MANAGER,'ColorOuterRed',0);
Outercolor.Green := ini.Readfloat(str_THOR_MANAGER,'ColorOuterGreen',0);
Outercolor.Blue := ini.Readfloat(str_THOR_MANAGER,'ColorOuterBlue',0);
Outercolor.Alpha := ini.Readfloat(str_THOR_MANAGER,'ColorOuterAlpha',0);
Corecolor.Red := ini.Readfloat(str_THOR_MANAGER,'ColorCoreRed',0);
Corecolor.Green := ini.Readfloat(str_THOR_MANAGER,'ColorCoreGreen',0);
Corecolor.Blue := ini.Readfloat(str_THOR_MANAGER,'ColorCoreBlue',0);
Corecolor.Alpha := ini.Readfloat(str_THOR_MANAGER,'ColorCoreAlpha',0);
Disabled := True;//weapon is inactive when the unit is created
end;
end;
if EnablePerlin then
begin
//******************** TO DO *********************//
// { TODO 3 -oDa Stranger -cExtending Capabilities : TO DO! }
//******************** TO DO *********************//
end;
if EnableFire then
begin
//******************** TO DO *********************//
// { TODO 3 -oDa Stranger -cExtending Capabilities : TO DO! }
//******************** TO DO *********************//
end;
end;
{ TRace }
{
************************************ TRace *************************************
}
constructor TRace.Create;
begin
inherited;
UnitTypes := TStringList.Create;
end;
destructor TRace.Destroy;
begin
inherited;
UnitTypes.Free;
end;
function TRace.GetUnitType(index: integer): TUnitType;
begin
Result := TUnitType(UnitTypes.Objects[index]);
end;
procedure TRace.LoadFromIni(ini: TStrangeIniFile; Section: string);
var
i: byte;
tmp: string;
begin
inherited;
XPNeededForNextLevel := ini.ReadFloat(Section,'XPNeededForNextLevel',XPNeededForNextLevel);
if not ini.SectionExists(str_UNITS) then
MakeError(str_ERROR_READING_SECTION + str_UNITS + str_FROM_FILE + ini.FileName + str_IT_DOES_NOT_EXIST,7);
ini.ReadSection(str_UNITS,UnitTypes);
tmp := ini.ReadString(Section,str_RACE_TYPE,'');
if Assigned(onRequestRaceType) then onRequestRaceType(self,tmp,0,RaceType,i);
if RaceType=nil then MakeError(str_RACE_TYPE + ' "' + tmp + str_MENTIONED_IN_FILE + ini.FileName + str_NOT_FOUND ,7);
end;
{ TShieldSettings }
{
******************************* TShieldSettings ********************************
}
procedure TShieldSettings.Assign(From: TShieldSettings);
begin
DefenceBonus := From.DefenceBonus;
HealthBonusAdd := From.HealthBonusAdd;
HealthBonusMult := From.HealthBonusMult;
HealthRegenerateRateBonusAdd := From.HealthRegenerateRateBonusAdd;
HealthRegenerateRateBonusMult := From.HealthRegenerateRateBonusMult;
ShieldsBonusAdd := From.ShieldsBonusAdd;
ShieldsBonusMult := From.ShieldsBonusMult;
ShieldsRegenerateRateBonusAdd := From.ShieldsRegenerateRateBonusAdd;
ShieldsRegenerateRateBonusMult := From.ShieldsRegenerateRateBonusMult;
end;
procedure TShieldSettings.LoadFromIni(ini:TStrangeIniFile; Section:string);
begin
if not ini.SectionExists(Section) then
MakeError(str_ERROR_READING_SECTION + Section + str_FROM_FILE + ini.FileName + str_IT_DOES_NOT_EXIST,7);
DefenceBonus := ini.ReadFloat(Section,'DefenceBonus', DefenceBonus);
HealthBonusAdd := ini.ReadFloat(Section,'HealthBonusAdd', HealthBonusAdd);
ShieldsBonusAdd := ini.ReadFloat(Section,'ShieldsBonusAdd', ShieldsBonusAdd);
HealthBonusMult := ini.ReadFloat(Section,'HealthBonusMult', HealthBonusMult);
ShieldsBonusMult := ini.ReadFloat(Section,'ShieldsBonusMult', ShieldsBonusMult);
HealthRegenerateRateBonusAdd := ini.ReadFloat(Section,'HealthRegenerateRateBonusAdd', HealthRegenerateRateBonusAdd);
ShieldsRegenerateRateBonusAdd := ini.ReadFloat(Section,'ShieldsRegenerateRateBonusAdd', ShieldsRegenerateRateBonusAdd);
HealthRegenerateRateBonusMult := ini.ReadFloat(Section,'HealthRegenerateRateBonusMult',HealthRegenerateRateBonusMult);
ShieldsRegenerateRateBonusMult := ini.ReadFloat(Section,'ShieldsRegenerateRateBonusMult',ShieldsRegenerateRateBonusMult);
end;
{ TWeaponSettings }
{
******************************* TWeaponSettings ********************************
}
procedure TWeaponSettings.Assign(From: TWeaponSettings);
begin
Power := From.Power;
RechargeInterval_small := From.RechargeInterval_small;
RechargeInterval_big := From.RechargeInterval_big;
WeaponRange := From.WeaponRange;
Accuracy := From.Accuracy;
DeltaAngle := From.DeltaAngle;
BurstNumber := From.BurstNumber;
end;
procedure TWeaponSettings.LoadFromIni(ini:TStrangeIniFile;Section:string);
begin
if not ini.SectionExists(Section) then
MakeError(str_ERROR_READING_SECTION + Section + str_FROM_FILE + ini.FileName + str_IT_DOES_NOT_EXIST,7);
Power := ini.ReadFloat(Section,'Power',Power);
WeaponRange := ini.ReadFloat(Section,'WeaponRange',WeaponRange);
RechargeInterval_small := ini.ReadFloat(Section,'RechargeInterval_small',RechargeInterval_small);
RechargeInterval_big := ini.ReadFloat(Section,'RechargeInterval_big',RechargeInterval_big);
Accuracy := ini.ReadFloat(Section,'Accuracy',Accuracy);
DeltaAngle := ini.ReadFloat(Section,'DeltaAngle',DeltaAngle);
BurstNumber := ini.ReadFloat(Section,'BurstNumber',BurstNumber);
end;
procedure TWeaponSettings.Multiply(From:TWeaponSettings);
begin
Power := Power * From.Power;
RechargeInterval_small := RechargeInterval_small * From.RechargeInterval_small;
RechargeInterval_big := RechargeInterval_big * From.RechargeInterval_big;
WeaponRange := WeaponRange * From.WeaponRange;
Accuracy := Accuracy * From.Accuracy;
DeltaAngle := DeltaAngle * From.DeltaAngle;
BurstNumber := BurstNumber * From.BurstNumber;
end;
{ TDamageMatrix }
{
******************************** TDamageMatrix *********************************
}
procedure TDamageMatrix.Assign(From: TDamageMatrix);
begin
AgainstRace := From.AgainstRace;
AgainstUnitClass := From.AgainstUnitClass;
end;
constructor TDamageMatrix.Create;
begin
//setlength(AgainstShipClass,length(SHIP_CLASSES));
//setlength(AgainstRace,length(RACE_TYPES));
end;
destructor TDamageMatrix.Destroy;
begin
setlength(AgainstUnitClass,0);
setlength(AgainstRace,0);
inherited;
end;
procedure TDamageMatrix.LoadFromIni(ini: TStrangeIniFile; WeaponType: TWeaponType);
var
len: Byte;
RaceType: TRaceType;
UnitClass: TUnitClass;
i: Byte;
begin
if Assigned(WeaponType.onRequestRaceType) then
WeaponType.onRequestRaceType(self,'',0,RaceType,len);
setlength(AgainstRace,len);
if len<>0 then
for i := 0 to len-1 do
begin
if Assigned(WeaponType.onRequestRaceType) then
WeaponType.onRequestRaceType(self,'',i,RaceType,len);
AgainstRace[i] := ini.ReadFloat(str_DAMAGE_MATRIX_AGAINST + str_RACE_TYPE,RaceType.Filename,1);
end;
if Assigned(WeaponType.onRequestUnitClass) then
WeaponType.onRequestUnitClass(self,'',0,UnitClass,len);
setlength(AgainstUnitClass,len);
if len<>0 then
for i := 0 to len-1 do
begin
if Assigned(WeaponType.onRequestUnitClass) then
WeaponType.onRequestUnitClass(self,'',i,UnitClass,len);
AgainstUnitClass[i] := ini.ReadFloat(str_DAMAGE_MATRIX_AGAINST + str_UNIT_CLASS,UnitClass.Filename,1);
end;
end;
{ TUnitTypeWeaponGroup }
{
***************************** TUnitTypeWeaponGroup *****************************
}
procedure TUnitTypeWeaponGroup.Assign(From: TUnitTypeWeaponGroup);
begin
CurrentWeapon := From.CurrentWeapon;
WeaponsAllowed := From.WeaponsAllowed;
WeaponSettings.Assign(From.WeaponSettings);
WeaponParams := From.WeaponParams;
end;
constructor TUnitTypeWeaponGroup.Create;
begin
inherited;
WeaponSettings := TWeaponSettings.Create;
end;
destructor TUnitTypeWeaponGroup.Destroy;
begin
setlength(WeaponParams, 0);
setlength(WeaponsAllowed, 0);
WeaponSettings.Destroy;
inherited;
end;
function TUnitTypeWeaponGroup.LastWeapon: Byte;
begin
Result := length(WeaponParams)- 1;
end;
procedure TUnitTypeWeaponGroup.LoadFromIni(ini: TStrangeIniFile ;Section: string;
UnitType: TUnitType);
var
i: Integer;
tmp: string;
List: TStringList;
begin
List := TStringList.Create;
if not ini.SectionExists(Section + str_WEAPONS_ALLOWED) then
MakeError(str_ERROR_READING_SECTION + Section + str_WEAPONS_ALLOWED + str_FROM_FILE + ini.FileName + str_IT_DOES_NOT_EXIST,7);
ini.ReadSection(Section + str_WEAPONS_ALLOWED,List);
setlength(WeaponsAllowed, List.Count);
for i := 0 to List.Count-1 do
begin
if Assigned(UnitType.OnRequestWeaponType) then UnitType.OnRequestWeaponType(UnitType,List[i],WeaponsAllowed[i]);
if WeaponsAllowed[i]=nil then MakeError(Section + str_WEAPONS_ALLOWED + ' "' + List[i] + str_MENTIONED_IN_FILE + ini.FileName + str_NOT_FOUND ,7);
end;
if not ini.SectionExists(Section + str_WEAPON_SETTINGS) then
MakeError(str_ERROR_READING_SECTION + Section + str_WEAPON_SETTINGS + str_FROM_FILE + ini.FileName + str_IT_DOES_NOT_EXIST,7);
WeaponSettings.LoadFromIni(ini,Section + str_WEAPON_SETTINGS);
tmp := ini.ReadString(Section + str_WEAPON_SETTINGS,STR_DEFAULT_WEAPON,'');
if Assigned(UnitType.OnRequestWeaponType) then UnitType.OnRequestWeaponType(UnitType,tmp,CurrentWeapon);
if CurrentWeapon=nil then MakeError(Section + str_WEAPON_SETTINGS + ' "' + tmp + str_MENTIONED_IN_FILE + ini.FileName + str_NOT_FOUND ,7);
if not ini.SectionExists(Section + str_WEAPONS) then
MakeError(str_ERROR_READING_SECTION + Section + str_WEAPONS + str_FROM_FILE + ini.FileName + str_IT_DOES_NOT_EXIST,7);
ini.ReadSection(Section + str_WEAPONS,List);
setlength(WeaponParams,List.Count);
if List.Count>0 then
for i := 0 to List.Count-1 do
with WeaponParams[i] do
begin
Position := AffineVectormake(
ini.ReadFloat(List[i],str_POSITION + 'X',0),
ini.ReadFloat(List[i],str_POSITION + 'Y',0),
ini.ReadFloat(List[i],str_POSITION + 'Z',0));
Direction := AffineVectormake(
ini.ReadFloat(List[i],str_DIRECTION + 'X',0),
ini.ReadFloat(List[i],str_DIRECTION + 'Y',0),
ini.ReadFloat(List[i],str_DIRECTION + 'Z',0));
UpVector := AffineVectormake(
ini.ReadFloat(List[i],str_UP_VECTOR + 'X',0),
ini.ReadFloat(List[i],str_UP_VECTOR + 'Y',0),
ini.ReadFloat(List[i],str_UP_VECTOR + 'Z',0));
TipPosition := AffineVectormake(
ini.ReadFloat(List[i],str_TIP_POSITION + 'X',0),
ini.ReadFloat(List[i],str_TIP_POSITION + 'Y',0),
ini.ReadFloat(List[i],str_TIP_POSITION + 'Z',0));
end;
List.Free;
end;
function TUnitTypeWeaponGroup.WeaponNumber: Byte;
begin
Result := length(WeaponParams)-1;
end;
{ TUnitClass }
{
********************************** TUnitClass **********************************
}
constructor TUnitClass.Create;
begin
inherited;
MovementSettings := TStrangeMovement.Create(nil);
ShieldSettings := TShieldSettings.Create;
WeaponSettings := TWeaponSettings.Create;
end;
destructor TUnitClass.Destroy;
begin
inherited;
MovementSettings.Destroy;
ShieldSettings.Destroy;
WeaponSettings.Destroy;
end;
procedure TUnitClass.LoadFromIni(ini: TStrangeIniFile; Section: string);
begin
inherited;
// MovementSettings.LoadSettingsFromFile(ini.FileName,str_MOVEMENT_SETTINGS + '_' + str_NEXT_XP_LEVEL,True);
ShieldSettings.LoadFromIni(ini,str_SHIELD_SETTINGS + '_' + str_NEXT_XP_LEVEL);
WeaponSettings.LoadFromIni(ini,str_WEAPON_SETTINGS + '_' + str_NEXT_XP_LEVEL);
ViewDistance := ini.ReadFloat(Section, str_VIEW_DISTANCE + str_NEXT_XP_LEVEL, ViewDistance);
MovementScannerDistance := ini.ReadFloat(Section, str_MOVEMENT_SCANNER_DISTANCE + str_NEXT_XP_LEVEL, MovementScannerDistance);
end;
{ TRaceType }
{
********************************** TRaceType ***********************************
}
procedure TRaceType.LoadFromIni(ini:TStrangeIniFile;Section:string);
begin
inherited;
SomeSetting := ini.ReadFloat(Section,'SomeSetting',SomeSetting);
end;
{ TPlayerUnitType }
procedure TPlayerUnitType.Assign(From: TPlayerUnitType);
var
Temp: TStringList;
begin
inherited Assign(From);
ActorNear := From.ActorNear;
ActorMedium := From.ActorMedium;
ActorFar := From.ActorFar;
TextureNear := From.TextureNear;
TextureMedium := From.TextureMedium;
TextureFar := From.TextureFar;
BoundingRadius := From.BoundingRadius;
BoundingDimentions := From.BoundingDimentions;
BoundingWidth := From.BoundingWidth;
MinExtents:= From.MinExtents;
MaxExtents := From.MaxExtents;
Temp := TStringList.Create;
From.ExplosionMemIniFile.GetStrings(Temp);
if ExplosionMemIniFile = nil then
ExplosionMemIniFile := TStrangeMemIniFile.Create('');
ExplosionMemIniFile.SetStrings(Temp);
From.EngineMemIniFile.GetStrings(Temp);
if EngineMemIniFile = nil then
EngineMemIniFile := TStrangeMemIniFile.Create('');
EngineMemIniFile.SetStrings(Temp);
Temp.Destroy;
end;
procedure TPlayerUnitType.AssignFromUnitType(From: TUnitType);
begin
inherited Assign(From);
end;
{$Warnings Off}
constructor TPlayerUnitType.Create;
begin
inherited Create;
AnimationStream := TStream.Create;
end;
{$Warnings On}
destructor TPlayerUnitType.Destroy;
begin
AnimationStream.Free;
ExplosionMemIniFile.Destroy;
EngineMemIniFile.Destroy;
inherited Destroy;
end;
end.
See more files for this project here