# Raw Documentation

## Main methods:

### PhotonFramework

#### PhotonFramework:Start()

This method must be called before any interaction is done with the framework, as it prepares all aspects of it.

```lua
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local PhotonFramework = ReplicatedStorage:WaitForChild("PhotonFramework"):WaitForChild("PhotonFramework")
PhotonFramework:Start()
```

### PhotonFramework.Objects

The Objects subtable is used to interact with both built-in objects and custom-made objects.

#### PhotonFramework.Objects:NewClass(ClassName:string,Class:table)

This method is used to create a new class, which can then be interacted with via the `PhotonFramework.Objects:GetClass` method.

```lua
PhotonFramework.Objects:NewClass("Demo Class",require(path.to.class))
```

{% hint style="warning" %}
Notice: the table supplied must contain a `.new` method, as the classes can be used to construct objects.  The `.new` method should return some form of data (either a metatable or a value).
{% endhint %}

#### PhotonFramework.Objects:GetClass(ClassName:string)

This method can be used to get the stored class data for any class that has been added to the framework (internal, custom, etc).

```lua
local DemoClass = PhotonFramework.Objects:GetClass("Demo Class")
```

#### PhotonFramework.Objects:AssignClass(Object:instance,ClassName:string)

This method is used to bind and construct a class with the supplied object.

```lua
PhotonFramework.Objects:AssignClass(workspace.SomePart,"Demo Class")
```

{% hint style="info" %}
The class will have the `.new` method called, and with the supplied object passed as the only argument.
{% endhint %}

#### PhotonFramework.Objects:GetObjectClass(Object:instance)

This method will return the class bound to the object via the `PhotonFramework.Objects:AssignClass` method.

```lua
local DemoClass = PhotonFramework.Objects:GetObjectClass(workspace.SomePart)
```

### PhotonFramework.Services

The services subtable is used to interact with services within the framework, both custom and built-in.

#### PhotonFramework.Services:GetService(ServiceName:string)

This method can be used to get a service from the framework, either a built-in one or custom one.

```lua
local CalculationService = PhotonFramework.Services:GetService("CalculationService")
```

#### PhotonFramework.Services:CreateService(ServiceName:string,Service:table,BootState:bool)

This method can be used to create a custom service within the framework.

```lua
local ServiceTable = {}
function ServiceTable:Initialize()
    print("Service initialized")
end
function ServiceTable:ping()
    print("pong")
end

PhotonFramework.Services:CreateService("CustomService",ServiceTable,false)

-- In a different script
local CustomService = PhotonFramework.Services:GetService("CustomService")
CustomService:ping() -- prints "pong"
```

{% hint style="danger" %}
The `BootState` property should never be set to true, as it is internally used during startup to index all services, then initialize them at the same time.
{% endhint %}

## Services:

### CalculationService

CalculationService is a service that's purpose is to make physics-based calculations within the engine easy to do.

```lua
local CalculationService = PhotonFramework.Services:GetService("CalculationService")
```

#### CalculationService:GetProjectileMotionAtTime(timeValue:number,projectileInitialPosition:Vector3,projectileInitialVelocity:Vector3)

This method will return the position of a theoretical (since there is no actual projectile passed in the arguments) position at x time (timeValue).  This can be used to model a projectile's path effectively.

```lua
local position = CalculationService:GetProjectileMotionAtTime(3,Vector3.new(0,5,0),Vector3.new(50,50,0))
```

### InstanceService

InstanceService allows for easy instance creation, while it does not contain much, it's the backbone of some more complex services.

```lua
local InstanceService = PhotonFramework.Services:GetService("InstanceService")
```

#### InstanceService:Create(ClassName:string,Properties:any,Callback)

This method will create an instance with a set of defined properties, and a callback if supplied.

```lua
InstanceService:Create("Part",{
		Anchored = true;
		Material = Enum.Material.Neon;
		Parent = workspace;
	},function(part)
	while task.wait() do
		part.CFrame = part.CFrame*CFrame.Angles(0,math.rad(1),0)
	end
end)
-- the Callback property is optional.
```

### SharedService

SharedService allows for data to be easily synced across multiple scripts.  It's a big table basically.

```lua
local SharedService = PhotonFramework.Services:GetService("SharedService")
```

#### SharedService:GetValue(key:any)

This is used to retrieve a value from the service.

```lua
local value = SharedService:GetValue(true) -- Value keys can be anything really.
```

#### SharedService:SetValue(key:any,value:any)

This is used to store a value in the service.

```lua
SharedService:SetValue(true,{"ok","it's true"})
```

### UIService

This service can be used to create advanced UIs easily with scripts.

```lua
local UIService = PhotonFramework.Services:GetService("UIService")
```

#### UIService:Create(ClassType:string)

This method can be used to create a UIService tree, which contains data to render a GUI.

```lua
local UIData = UIService:Create("ScreenGui") -- basically define the GUI type here.
```

#### UIService:Object(object:string,properties:table,children:table,connections:table,callback)

This method is used to create a UI object (such as a text button), which can then be added to a UI tree.

```lua
local object = UIService:Object("TextButton",{
    Text = "Hi";
},{
    MouseButton1Click = function()
        print("click")
    end;
},function(button)
    print(button.Name)
end)
```

#### UIService:Add(object:instance,tree:table)

This method is used to add an object to a UI tree.

```lua
UIService:Add(object,UIData)
```

#### UIService:Render(container:Instance,tree:table)

This method is used to render a UI tree.

```lua
UIService:Render(game:GetService("Players").LocalPlayer.PlayerGui,UIData)
```

### UUIDService

UUIDService is a service that allows the creation of a unique string (for said server, does not save). 

```lua
local UUIDService = PhotonFramework.Services:GetService("UUIDService")
```

#### UUIDService:GenerateUUID(length:number)

This method generates a random, unique string that is the supplied length long.

```lua
local response = UUIDService:GenerateUUID(5)
print(response) -- response will be a random string of characters.
```

#### UUIDService:GenerateUUIDCustomCharacters(length:number,characters:table)

This method generates a string of characters from a custom list.

```lua
local response = UUIDService:GenerateUUIDCustomCharacters(5,{"a","b",1,2,3})
```

This concludes the API documentation *for now*.