|
|
IFXAuthorPointSet Class ReferenceThis is the main interface for IFXAuthorPointSet.
More...
Inheritance diagram for IFXAuthorPointSet:
List of all members.
|
Public Member Functions |
| virtual IFXRESULT IFXAPI | Allocate (const IFXAuthorPointSetDesc *pPointDesc)=0 |
| virtual IFXRESULT IFXAPI | Reallocate (const IFXAuthorPointSetDesc *pPointDesc)=0 |
| virtual IFXRESULT IFXAPI | Deallocate ()=0 |
| virtual IFXRESULT IFXAPI | Copy (IFXREFIID interfaceID, void **ppNewAuthorPointSet)=0 |
virtual IFXAuthorPointSetDesc
*IFXAPI | GetPointSetDesc ()=0 |
| virtual IFXRESULT IFXAPI | SetPointSetDesc (const IFXAuthorPointSetDesc *pPointSetDesc)=0 |
virtual IFXAuthorPointSetDesc
*IFXAPI | GetMaxPointSetDesc ()=0 |
| virtual IFXRESULT IFXAPI | GetNumAllocatedTexPointLayers (U32 *pLayers)=0 |
| virtual IFXRESULT IFXAPI | GetPositionPoints (U32 **ppPositionPoint)=0 |
| virtual IFXRESULT IFXAPI | GetNormalPoints (U32 **ppNormalPoint)=0 |
| virtual IFXRESULT IFXAPI | GetDiffusePoints (U32 **ppDiffusePoint)=0 |
| virtual IFXRESULT IFXAPI | GetSpecularPoints (U32 **ppSpecularPoint)=0 |
| virtual IFXRESULT IFXAPI | GetTexCoordsPoints (U32 **ppTexCoordPoints)=0 |
| virtual IFXRESULT IFXAPI | GetMaterialsPoints (U32 **ppMaterialPoints)=0 |
| virtual IFXRESULT IFXAPI | GetPositionPoint (U32 index, U32 *pPositionPoint)=0 |
| virtual IFXRESULT IFXAPI | SetPositionPoint (U32 index, const U32 *pPositionPoint)=0 |
| virtual IFXRESULT IFXAPI | GetNormalPoint (U32 index, U32 *pNormalPoint)=0 |
| virtual IFXRESULT IFXAPI | SetNormalPoint (U32 index, const U32 *pNormalPoint)=0 |
| virtual IFXRESULT IFXAPI | GetDiffusePoint (U32 index, U32 *pDiffusePoint)=0 |
| virtual IFXRESULT IFXAPI | SetDiffusePoint (U32 index, const U32 *pDiffusePoint)=0 |
| virtual IFXRESULT IFXAPI | GetSpecularPoint (U32 index, U32 *pSpecularPoint)=0 |
| virtual IFXRESULT IFXAPI | SetSpecularPoint (U32 index, const U32 *pSpecularPoint)=0 |
| virtual IFXRESULT IFXAPI | GetMaterials (IFXAuthorMaterial **ppMaterials)=0 |
| virtual IFXRESULT IFXAPI | GetPointMaterials (U32 **ppPointMaterials)=0 |
| virtual IFXRESULT IFXAPI | GetMaterial (U32 index, IFXAuthorMaterial *pMaterial)=0 |
| virtual IFXRESULT IFXAPI | SetMaterial (U32 index, const IFXAuthorMaterial *pMaterial)=0 |
| virtual IFXRESULT IFXAPI | GetTexPoints (U32, U32 **)=0 |
| virtual IFXRESULT IFXAPI | GetPositions (IFXVector3 **)=0 |
| virtual IFXRESULT IFXAPI | GetNormals (IFXVector3 **)=0 |
| virtual IFXRESULT IFXAPI | GetTexCoords (IFXVector4 **)=0 |
| virtual IFXRESULT IFXAPI | GetDiffuseColors (IFXVector4 **)=0 |
| virtual IFXRESULT IFXAPI | GetSpecularColors (IFXVector4 **)=0 |
| virtual IFXRESULT IFXAPI | GetPosition (U32 index, IFXVector3 *pVector3)=0 |
| virtual IFXRESULT IFXAPI | SetPosition (U32 index, const IFXVector3 *pVector3)=0 |
| virtual IFXRESULT IFXAPI | GetNormal (U32 index, IFXVector3 *pVector3)=0 |
| virtual IFXRESULT IFXAPI | SetNormal (U32 index, const IFXVector3 *pVector3)=0 |
| virtual IFXRESULT IFXAPI | GetDiffuseColor (U32 index, IFXVector4 *pColor)=0 |
| virtual IFXRESULT IFXAPI | SetDiffuseColor (U32 index, IFXVector4 *pColor)=0 |
| virtual IFXRESULT IFXAPI | GetSpecularColor (U32 index, IFXVector4 *pColor)=0 |
| virtual IFXRESULT IFXAPI | SetSpecularColor (U32 index, IFXVector4 *pColor)=0 |
| virtual IFXRESULT IFXAPI | GetTexCoord (U32 index, IFXVector4 *pVector4)=0 |
| virtual IFXRESULT IFXAPI | SetTexCoord (U32 index, const IFXVector4 *pVector4)=0 |
| virtual IFXRESULT IFXAPI | GetPointMaterial (U32 index, U32 *pPointMaterial)=0 |
| virtual IFXRESULT IFXAPI | SetPointMaterial (U32 index, U32 pointMaterialID)=0 |
| virtual IFXRESULT IFXAPI | GetTexPoint (U32 layer, U32 index, U32 *pTexturePoint)=0 |
| virtual IFXRESULT IFXAPI | SetTexPoint (U32 layer, U32 index, const U32 *pTexturePoint)=0 |
| virtual IFXVector4 IFXAPI | CalcBoundSphere ()=0 |
Detailed Description
This is the main interface for IFXAuthorPointSet.
Provides high-level information about a Point set; namely, what attributes are present in the PointSet and how many elements can be found in each attribute array.
- Note:
- The associated IID is named IID_IFXAuthorPointSet.
Member Function Documentation
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::Allocate |
( |
const IFXAuthorPointSetDesc * |
pPointDesc |
) |
[pure virtual] |
|
|
|
Allocates all the necessary space required by the fully-populated IFXAuthorPointSet.
- Parameters:
-
| pPointDesc | The IFXAuthorPointSet data structure describing the properties of the Point set. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pPointDesc was NULL |
| IFX_E_INVALID_RANGE | The number of materials or positions was less than one. |
| IFX_E_OUT_OF_MEMORY | There was insufficiant memory to allocate the Point set. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXVector4 IFXAPI IFXAuthorPointSet::CalcBoundSphere |
( |
|
) |
[pure virtual] |
|
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::Copy |
( |
IFXREFIID |
interfaceID, |
|
|
void ** |
ppNewAuthorPointSet |
|
) |
[pure virtual] |
|
|
|
Creates a complete copy of the IFXAuthorPointSet and returns it with the specified interface.
- Parameters:
-
| interfaceID | The IID of the desired PointSet interface |
| ppNewAuthorPointSet | - a pointer to the new AuthorPointSet copy. |
- Returns:
- An IFXRESULT value.
- Return values:
-
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::Deallocate |
( |
|
) |
[pure virtual] |
|
|
|
Frees all data associated with the PointSet.
- Returns:
- An IFXRESULT value.
- Return values:
-
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetDiffuseColor |
( |
U32 |
index, |
|
|
IFXVector4 * |
pColor |
|
) |
[pure virtual] |
|
|
|
Retrieves a specific Diffuse vertex color from this Pointset.
- Parameters:
-
| index | The index of the Diffuse vertex color to return |
| pColor | The requested color |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pColor was NULL |
| IFX_E_INVALID_RANGE | index is larger than the number of diffuse vertex colors stored in the Pointset. |
- Note:
- Vertex colors are stored in BGRA order.
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetDiffuseColors |
( |
IFXVector4 ** |
|
) |
[pure virtual] |
|
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetDiffusePoint |
( |
U32 |
index, |
|
|
U32 * |
pDiffusePoint |
|
) |
[pure virtual] |
|
|
|
Retrieves a specific Diffuse vertex color Point index.
- Parameters:
-
| index | The index of the diffuse Point to return |
| pDiffuseFace | The diffuse face containing the diffuse vertex color indices. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pDiffusePoint was NULL |
| IFX_E_INVALID_RANGE | The index is greater than the number of diffuse vertex color Point in the PointSet. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetDiffusePoints |
( |
U32 ** |
ppDiffusePoint |
) |
[pure virtual] |
|
|
|
Returns the pointer to the PointSet Diffuse Colors index array.
- Parameters:
-
| ppDiffusePoint | The array of IFXPoint specifying the indices of the diffuse colors used by each vertex on each face. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | ppDiffusePoint was NULL. |
| IFX_E_INVALID_RANGE | The PointSet does not contain this attribute. NumDiffuseColors in the IFXPoint is equal to zero(0). |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetMaterial |
( |
U32 |
index, |
|
|
IFXAuthorMaterial * |
pMaterial |
|
) |
[pure virtual] |
|
|
|
Retrieves a specific material by index.
- Parameters:
-
| index | The index of the material to return |
| pMaterial | A pointer to the material. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pMaterial was NULL. |
| IFX_E_INVALID_RANGE | The index is invalid |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetMaterials |
( |
IFXAuthorMaterial ** |
ppMaterials |
) |
[pure virtual] |
|
|
|
Returns the pointer to the Material Definition Array.
- Parameters:
-
| ppMaterials | The pointer to the material definition array |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | ppMaterials was NULL. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetMaterialsPoints |
( |
U32 ** |
ppMaterialPoints |
) |
[pure virtual] |
|
|
|
Returns the pointer to the PointSet Materials index array.
- Parameters:
-
| ppMaterialPoints | The array of IFXPoint specifying the indices of the meterials used by each vertex on each face. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | ppMaterialPoints was NULL. |
| IFX_E_INVALID_RANGE | The PointSet does not contain this attribute. NumMaterials in the IFXPoint is equal to zero(0). |
Implemented in CIFXAuthorPointSet. |
|
|
Returns the maximum resolution PointSet description.
- Returns:
- A pointer to an IFXAuthorPointSetDesc structure describing the full-resolution representation of the PointSet.
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetNormal |
( |
U32 |
index, |
|
|
IFXVector3 * |
pVector3 |
|
) |
[pure virtual] |
|
|
|
Retrieves a specific Normal from this Pointset.
- Parameters:
-
| index | The index of the normal to return |
| pVector3 | The requested normal |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pVector3 was NULL |
| IFX_E_INVALID_RANGE | index is larger than the number of normals stored in the Pointset. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetNormalPoint |
( |
U32 |
index, |
|
|
U32 * |
pNormalPoint |
|
) |
[pure virtual] |
|
|
|
Retrieves a specific Normal Point index.
- Parameters:
-
| index | The index of the normal Point to return |
| pNormalPoint | The returned face containing normal indices |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pNormalPoint was NULL |
| IFX_E_INVALID_RANGE | The index is greater than the number of normal Point in the Pointset. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetNormalPoints |
( |
U32 ** |
ppNormalPoint |
) |
[pure virtual] |
|
|
|
Returns the pointer to the PointSet Normal index array.
- Parameters:
-
| ppNormalPoint | The array of IFXPoint specifying the indices of the normals used by each vertex on each face. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | ppNormalPoint was NULL |
| IFX_E_INVALID_RANGE | The PointSet does not contain this attribute. NumNormals in the IFXAuthorPointSetDesc is equal to zero(0). |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetNormals |
( |
IFXVector3 ** |
|
) |
[pure virtual] |
|
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetNumAllocatedTexPointLayers |
( |
U32 * |
pLayers |
) |
[pure virtual] |
|
|
|
Returns the number of texPoint layers, where texPoints layers are allocated on demand to save memory.
- Parameters:
-
| pLayers | The number of layers allocated |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pLayers was NULL |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetPointMaterial |
( |
U32 |
index, |
|
|
U32 * |
pPointMaterial |
|
) |
[pure virtual] |
|
|
|
Retrieves a specific Material Point ID.
- Parameters:
-
| index | The index of the Point for which we want the material ID |
| pPointMaterial | The returned material ID. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | puFaceMaterial was NULL |
| IFX_E_INVALID_RANGE | index was larger than the number of faces in the PointSet. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetPointMaterials |
( |
U32 ** |
ppPointMaterials |
) |
[pure virtual] |
|
|
|
Returns the pointer to the Point Material index array.
- Parameters:
-
| ppPointMaterials | The array of U32es specifying the material index to use on each face of the Pointset |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | ppFaceMaterials was NULL. |
| IFX_E_INVALID_RANGE | The Pointset does not contain this attribute. NumMaterials in the IFXAuthorPointDesc is equal to zero(0). |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetPosition |
( |
U32 |
index, |
|
|
IFXVector3 * |
pVector3 |
|
) |
[pure virtual] |
|
|
|
Retrieves a specific vertex position from the Point Set.
- Parameters:
-
| index | The index of the vertex position to return |
| pVector3 | The position of the specified vertex |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pVector3 was NULL |
| IFX_E_INVALID_RANGE | index is larger than the number of vertex positions stored in the Point set. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetPositionPoint |
( |
U32 |
index, |
|
|
U32 * |
pPositionPoint |
|
) |
[pure virtual] |
|
|
|
Retrieves a specific Position face index.
- Parameters:
-
| index | The index of the position Point to return |
| pPositionPoint | The returned Point containing position indices |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pPositionPoint was NULL |
| IFX_E_INVALID_RANGE | The index is greater than the number of position Point segm in the Pointset. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetPositionPoints |
( |
U32 ** |
ppPositionPoint |
) |
[pure virtual] |
|
|
|
Returns the pointer to the Point Position index array.
- Parameters:
-
| ppPositionPoint | The array of IFXPoint specifying the indices of the positions for each vertex on each Point. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | ppPositionPoint was NULL. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetPositions |
( |
IFXVector3 ** |
|
) |
[pure virtual] |
|
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetSpecularColor |
( |
U32 |
index, |
|
|
IFXVector4 * |
pColor |
|
) |
[pure virtual] |
|
|
|
Retrieves a specific Specular vertex color from this Pointset.
- Parameters:
-
| index | The index of the specular vertex color to return |
| pColor | The requested color value |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pColor was NULL |
| IFX_E_INVALID_RANGE | index is larger than the number of specular vertex colors stored in the Pointset. |
- Note:
- Vertex colors are stored in BGRA order.
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetSpecularColors |
( |
IFXVector4 ** |
|
) |
[pure virtual] |
|
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetSpecularPoint |
( |
U32 |
index, |
|
|
U32 * |
pSpecularPoint |
|
) |
[pure virtual] |
|
|
|
Retrieves a specific Specular face index.
- Parameters:
-
| index | The index of the specular Point to return |
| pSpecularFace | The specular Point containing the specular vertex color indices. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pSpecularPoint was NULL |
| IFX_E_INVALID_RANGE | The index is greater than the number of specular vertex color Point in the PointSet. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetSpecularPoints |
( |
U32 ** |
ppSpecularPoint |
) |
[pure virtual] |
|
|
|
Returns the pointer to the PointSet Specular Colors index array.
- Parameters:
-
| ppSpecularFaces | The array of IFXPoint specifying the indices of the specular colors used by each vertex on each face. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | ppSpecularFaces was NULL. |
| IFX_E_INVALID_RANGE | The PointSet does not contain this attribute. NumSpecularColors in the IFXPoint is equal to zero(0). |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetTexCoord |
( |
U32 |
index, |
|
|
IFXVector4 * |
pVector4 |
|
) |
[pure virtual] |
|
|
|
Retrieves a specific Texture Coordinate from this Pointset.
- Parameters:
-
| index | The index of the texture coordinate to return |
| pVector4 | The requested texture coordinate |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pVector4 was NULL |
| IFX_E_INVALID_RANGE | index is larger than the number of texture coordinates stored in the Pointset. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetTexCoords |
( |
IFXVector4 ** |
|
) |
[pure virtual] |
|
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetTexCoordsPoints |
( |
U32 ** |
ppTexCoordPoints |
) |
[pure virtual] |
|
|
|
Returns the pointer to the PointSet Texture Coordinates index array.
- Parameters:
-
| ppTexCoordPoints | The array of IFXPoint specifying the indices of the texture coordinates used by each vertex on each face. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | ppTexCoordPoints was NULL. |
| IFX_E_INVALID_RANGE | The PointSet does not contain this attribute. NumTexCoords in the IFXPoint is equal to zero(0). |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetTexPoint |
( |
U32 |
layer, |
|
|
U32 |
index, |
|
|
U32 * |
pTexturePoint |
|
) |
[pure virtual] |
|
|
|
Retrieves a specific Texture Point index.
- Parameters:
-
| layer | The texture coordinate layer this Point is from |
| index | The index of the texture face to return |
| pTextureLine | The texture Point containing the texture coordinate indices |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pTextureFace was NULL |
| IFX_E_INVALID_RANGE | index is greater than the number of texture coordinate Points in the Point set, the Point set has no texture coordinates, or layer is greater than IFXMAX_TEX_COORD_LAYERS. |
| IFX_E_OUT_OF_MEMORY | We were not able to allocate memory for a new texture layer. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::GetTexPoints |
( |
U32 |
, |
|
|
U32 ** |
|
|
) |
[pure virtual] |
|
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::Reallocate |
( |
const IFXAuthorPointSetDesc * |
pPointDesc |
) |
[pure virtual] |
|
|
|
Reallocates the PointSet based on the new PointSet description.
- Parameters:
-
| pPointDesc | The new properties of the PointSet. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pPointDesc was NULL |
| IFX_E_INVALID_RANGE | The number of materials or positions was less than one. |
| IFX_E_OUT_OF_MEMORY | There was insufficient memory to allocate the PointSet. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::SetDiffuseColor |
( |
U32 |
index, |
|
|
IFXVector4 * |
pColor |
|
) |
[pure virtual] |
|
|
|
Sets a specific Diffuse vertex color for this Pointset.
- Parameters:
-
| index | The index of the diffuse vertex color to set |
| pColor | The new diffuse vertex color to store |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pColor was NULL |
| IFX_E_INVALID_RANGE | index is larger than the number of diffuse vertex colors stored in the Pointset. |
- Note:
- Vertex colors are stored in BGRA order.
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::SetDiffusePoint |
( |
U32 |
index, |
|
|
const U32 * |
pDiffusePoint |
|
) |
[pure virtual] |
|
|
|
Set a specific Diffuse Point index.
- Parameters:
-
| index | The index of the diffuse Point to set |
| pDiffuseFace | The diffuse Point containing the diffuse vertex color index data to set |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pDiffusePoint was NULL |
| IFX_E_INVALID_RANGE | The index is greater than the number of diffuse vertex color Point in the PointSet. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::SetMaterial |
( |
U32 |
index, |
|
|
const IFXAuthorMaterial * |
pMaterial |
|
) |
[pure virtual] |
|
|
|
Sets a specific material Point.
- Parameters:
-
| index | The index of the material to set |
| pMaterial | A pointer to the material to assign to this index. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pMaterial was NULL |
| IFX_E_INVALID_RANGE | The index is greater than the number of materials used by the Pointset. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::SetNormal |
( |
U32 |
index, |
|
|
const IFXVector3 * |
pVector3 |
|
) |
[pure virtual] |
|
|
|
Sets a specific Normal for this Pointset.
- Parameters:
-
| index | The index of the normal to set |
| pVector3 | The new value of the normal |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pVector3 was NULL |
| IFX_E_INVALID_RANGE | index is larger than the number of normals stored in the Pointset. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::SetNormalPoint |
( |
U32 |
index, |
|
|
const U32 * |
pNormalPoint |
|
) |
[pure virtual] |
|
|
|
Set a specific Normal Point index.
- Parameters:
-
| index | The index of the normal face to return |
| pNormalPoint | The normal Point containing the normal index data to set. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pNormalPoint was NULL |
| IFX_E_INVALID_RANGE | The index is greater than the number of normal Point in the PointSet. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::SetPointMaterial |
( |
U32 |
index, |
|
|
U32 |
pointMaterialID |
|
) |
[pure virtual] |
|
|
|
Sets a specific Point Material ID.
- Parameters:
-
| index | The index of the face on which we want to set the material ID. |
| pointMaterialID | The material ID to set on the face. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_RANGE | index was larger than the number of faces in the PointSet. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::SetPointSetDesc |
( |
const IFXAuthorPointSetDesc * |
pPointSetDesc |
) |
[pure virtual] |
|
|
|
Sets the current IFXPointSetDesc description (as opposed to the MaxPointSetDesc which is set when the PointSet is allocated).
- Parameters:
-
| pPointSetDesc | The new IFXPointSetDesc description |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_RANGE | One of the values in pPointSetDesc is larger than the IFXPointSetDesc used to allocate the PointSet, and/or the number of materials is not the same as when the PointSet was allocated. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::SetPosition |
( |
U32 |
index, |
|
|
const IFXVector3 * |
pVector3 |
|
) |
[pure virtual] |
|
|
|
Sets a specific vertex position for this Pointset.
- Parameters:
-
| index | The index of the vertex position to set |
| pVector3 | The new position value for this vertex |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pVector3 was NULL |
| IFX_E_INVALID_RANGE | index is larger than the number of vertex positions stored in the Pointset. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::SetPositionPoint |
( |
U32 |
index, |
|
|
const U32 * |
pPositionPoint |
|
) |
[pure virtual] |
|
|
|
Sets a specific Position Point index.
- Parameters:
-
| index | The index of the position face to set |
| pPositionPoint | The position Point containing the position index data to set. |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pPositionLien was NULL |
| IFX_E_INVALID_RANGE | The index is greater than the number of position faces in the Pointset. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::SetSpecularColor |
( |
U32 |
index, |
|
|
IFXVector4 * |
pColor |
|
) |
[pure virtual] |
|
|
|
Sets a specific Specular vertex color of this Pointset.
- Parameters:
-
| index | The index of the specular vertex color to set |
| pColor | The new specular vertex color to store |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pColor was NULL |
| IFX_E_INVALID_RANGE | index is larger than the number of specular vertex colors stored in the Pointset. |
- Note:
- Vertex colors are stored in BGRA order.
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::SetSpecularPoint |
( |
U32 |
index, |
|
|
const U32 * |
pSpecularPoint |
|
) |
[pure virtual] |
|
|
|
Set a specific Specular Point index.
- Parameters:
-
| index | The index of the specular Point to set |
| pSpecularFace | The specular face containing the specular vertex color index data to set |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pSpecularPoint was NULL |
| IFX_E_INVALID_RANGE | The index is greater than the number of specular vertex color Point in the PointSet. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::SetTexCoord |
( |
U32 |
index, |
|
|
const IFXVector4 * |
pVector4 |
|
) |
[pure virtual] |
|
|
|
Sets specific Texture Coordinate for this Pointset.
- Parameters:
-
| index | The index of the texture coordinate to set |
| pVector4 | The new texture coordinate value to store |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pVector4 was NULL |
| IFX_E_INVALID_RANGE | index is larger than the number of texture coordinates stored in the Pointset. |
Implemented in CIFXAuthorPointSet. |
| virtual IFXRESULT IFXAPI IFXAuthorPointSet::SetTexPoint |
( |
U32 |
layer, |
|
|
U32 |
index, |
|
|
const U32 * |
pTexturePoint |
|
) |
[pure virtual] |
|
|
|
Sets a specific Texture Point index.
- Parameters:
-
| layer | The texture coordinate layer into which to place the Point |
| index | The index of the texture face to set |
| pTextureLine | The texture Point containing the texture coordinate indices to set in the Point set |
- Returns:
- An IFXRESULT value.
- Return values:
-
| IFX_OK | No error. |
| IFX_E_INVALID_POINTER | pTextureFace was NULL |
| IFX_E_INVALID_RANGE | index is greater than the number of texture coordinate faces in the Point set, the Point set has no texture coordinates, or layer is greater than IFXMAX_TEX_COORD_LAYERS. |
| IFX_E_OUT_OF_MEMORY | We were not able to allocate memory for a new texture layer. |
Implemented in CIFXAuthorPointSet. |
© 1999 - 2006 Intel Corporation. All rights reserved.
* Other names and brands may be claimed as the property of others.
|
|


#include <MSettingsStorage.h>
Inheritance diagram for CSettingsStorage:
Derive from it and implement the Integer, Simple and Extended types SaveLoadItem() functions. Implement also the Implementation overrideables functions.
It's up to the derived class to add methods for opening and closing the storage.
Definition at line 118 of file MSettingsStorage.h.
Implementation overrideables | |
| virtual CSettingsStorage * | CreateSubStorage (LPCTSTR SubName)=0 |
| Subclasses must override this function to return a heap allocated object that represent a substorage of this. | |
| virtual bool | ContinueOnError ()=0 |
| The result of this function is used to determine if the storage may continue to read/write items after a failed one. | |
Overrideables | |
| Returning false in OnBeforeXXX() will disable the calls to SaveLoadItem() but OnAfterXXX() will still be called. | |
| virtual bool | OnBeforeSave () |
| virtual bool | OnAfterSave () |
| virtual bool | OnBeforeLoad () |
| virtual bool | OnAfterLoad () |
Integer types | |
| The derived class must implement them. | |
| virtual bool | SaveLoadItem (LPCTSTR szName, long &Variable, bool bSave)=0 |
| virtual bool | SaveLoadItem (LPCTSTR szName, unsigned long &Variable, bool bSave)=0 |
Simple types | |
| The derived class must implement them. | |
| virtual bool | SaveLoadItem (LPCTSTR szName, bool &Variable, bool bSave)=0 |
| virtual bool | SaveLoadItem (LPCTSTR szName, double &Variable, bool bSave)=0 |
Extended types | |
| The derived class must implement them. | |
| virtual bool | SaveLoadItem (LPCTSTR szName, TCHAR *Variable, ULONG &size, bool bSave)=0 |
| Strings. | |
| virtual bool | SaveLoadItem (LPCTSTR szName, void *Variable, ULONG size, bool bSave)=0 |
| void* (binary). | |
Helpers functions | |
| These functions handles conversion from/to similar types of the handled ones (the ones that are pure virtual).
The derived class does not need to override them, but they are still made virtual in case special handling is desired. | |
| virtual bool | SaveLoadItem (LPCTSTR szName, int &Variable, bool bSave) |
| virtual bool | SaveLoadItem (LPCTSTR szName, unsigned int &Variable, bool bSave) |
| virtual bool | SaveLoadItem (LPCTSTR szName, short &Variable, bool bSave) |
| virtual bool | SaveLoadItem (LPCTSTR szName, unsigned short &Variable, bool bSave) |
| virtual bool | SaveLoadItem (LPCTSTR szName, signed char &Variable, bool bSave) |
| virtual bool | SaveLoadItem (LPCTSTR szName, unsigned char &Variable, bool bSave) |
| virtual bool | SaveLoadItem (LPCTSTR szName, LONGLONG &Variable, bool bSave) |
| virtual bool | SaveLoadItem (LPCTSTR szName, ULONGLONG &Variable, bool bSave) |
| virtual bool | SaveLoadItem (LPCTSTR szName, float &Variable, bool bSave) |
| virtual bool | SaveLoadItem (LPCTSTR szName, CSettings &Variable, bool bSave) |
| CSettings (sub items), If overrideen, the derived class must (at a point that make sense) call the Variable.InternalSaveLoad() function. | |
Collections Templates | |
| These are templates that handle collections of any CSettings subclass. | |
| template<class TArray, class TArrayItem> bool | SaveLoadItemCArray (LPCTSTR szName, TArray &Variable, TArrayItem &dummy, bool bSave) |
| ATL CSimpleArray<T>, MFC CArray<T>. | |
| template<class TSTLArray> bool | SaveLoadItemSTL (LPCTSTR szName, TSTLArray &Variable, bool bSave) |
| std::vector<T>, std::list<T>, std::deque<T> | |
| template<class TArray, class TArrayItem> bool | SaveLoadItemCArrayAlone (LPCTSTR szName, TArray &Variable, TArrayItem &dummy, bool bSave) |
| ATL CSimpleArray<T>, MFC CArray<T> for standalone types. | |
| template<class TSTLArray> bool | SaveLoadItemSTLAlone (LPCTSTR szName, TSTLArray &Variable, bool bSave) |
| std::vector<T>, std::list<T>, std::deque<T> for standalone types | |
Collections related functions | |
| The derived class can implement them directly.
If it does not, standard behaviour is provided. The standard behaviour is 'Count' based, so the derived storage has to be Name/Value pair behavioured. | |
| virtual bool | OnBeginCollection (LPCTSTR szName, UINT &ItemCount, bool bSave) |
| Called before browsing items. | |
| virtual int | OnItemCollection (UINT Index, CSettings &variable, bool bSave) |
| Called for each item in the collection. | |
| virtual bool | OnEndCollection (bool bSave) |
| Called after browsing all items. | |
| virtual bool | OnBeginAloneCollection (LPCTSTR szName, UINT &ItemCount, bool bSave) |
| Internal function for stand-alone types collections. | |
| virtual int | OnItemAloneCollection (UINT Index, bool bSave, LPCTSTR &ItemName) |
| Called before each item in the stand-alone collection. | |
| virtual bool | OnEndAloneCollection (bool bSave) |
| Internal function for stand-alone types collections. |
|
|
Subclasses must override this function to return a heap allocated object that represent a substorage of this. SaveLoadItem() functions will be called from this substorage. So the returned Storage object must be opened with the SubName and ready to operate, but OnBeforeXXX() will be called before any SaveLoadItem(). |
|
|
Strings.
When saving, size contains the length of the string. This function can ignore it. |
|
|
Called before browsing items.
When saving: If ItemCount contains 0xFFFFFFFF, it indicates that the count is not known, but the implementor should handle this case. He should count the number of OnItemCollection() calls to determine the count (if needed). Definition at line 192 of file MSettingsStorage.h. |
|
|
Called for each item in the collection.
Definition at line 215 of file MSettingsStorage.h. |
|
|
Called before each item in the stand-alone collection. Generate here the item name and put it in ItemName. Subclasses can override it to changes the standard behaviour which is: "Item.%i" where i is the Index.
Definition at line 289 of file MSettingsStorage.h. |


{% extends "layouts/govuk-registers.html" %} {% set section = "index" %} {% block page_title %} GOV.UK prototype kit {% endblock %} {% block content %} Department for Business, Energy and Industrial Strategy Change contact Name Responsible for Email address Save changes {% endblock %}


Adventure Rogue-like
About Game
Adventure is a 2D roguelike, complete with procedurally generated maps, perma-death, a quest system, and a party system. Originally, this project was assigned over 5 weeks in my first software development class at Guildhall. I later decided to take the game further by continuing development over an 8-week directed focus study, and during my own time outside of class. My goal with development was to move beyond the standard roguelike formula, and give the player a sense of growth from quest to quest. I worked to achieve this by developing my map generation system, and modeling gameplay after my favorite arc in the popular Dungeons and Dragons podcast “The Adventure Zone.” The breadth of this project allowed me to explore many areas of interest for me – including procedural generation, AI, UI, and system design - and will continue to be a great project to return to and polish into a finished game.
In adventure, the player spawns into a large map, filled with both friendly and hostile entities. The player must explore the map to complete a main quest, which will bring them to the next encounter. But, the player can spend more time searching to complete side quests, to grant them more equipment, stats, and even new party members. As the player moves through encounters, the maps get progressively harder, with more and more high-level enemies spawning. The player must survive through as many encounters as possible, until their entire party dies out.
Game Features
Map Generation
Maps in Adventure are generated through a sequence of generation steps, defined in data. For this system, I implemented a large number of generation step types, which, when used in tandem, can create exciting, organic 2D maps. To expand on this system, I added a masking system, which allowed generation steps to be run on a sub-area of the main map. These subareas can be defined as rectangles, circles, or perlin noise ranges. This system is extremely buildable – I can easily add new generation steps, and quickly see results on the screen.
| Generation Step | Description |
|---|---|
| Mutate | Checks every tile, and has a random chance to change tile to a defined type (if that tile meets the parameters) |
| FillAndEdge | Fills the area with one tile type, and edges it with another |
| CellularAutomata | Changes a tile based on its neighbors. |
| SpawnItem, SpawnActor, Spawn Decoration | Adds entities to the map. Can specify what kind of tiles to spawn on, or which tags the entity can or cannot spawn on. |
| RoomAndPath | Creates rooms, and generates paths between them. Can modify how many rooms, how many times rooms can overlap, how straight the paths should be, how large the rooms are, and what tiles the rooms/paths are made of. Useful for creating man-made looking structures like villages. |
| FromFile | Loads an image from file, and parses it as tiles, using the tiles defined chromakey. |
| SetSubArea | Sets a subarea for all generation steps beneath it. |
| EndSubArea | Returns the subarea to the current subarea’s parent subarea. |
| Submap | Runs all map generation steps from another defined map. Can be used in a subarea to generate a small map within a much larger map. |
Organic Tile Edges
As I worked on the map generation more, I found that the maps were starting to look ~really good~ when I was zoomed out and looking at the entire map. But on the actual game screen, while walking around, they still looked very unpolished, because of the harsh edges between tiles. The Liberated Pixel Cup tileset that I was using came with an incomplete set of cosmetic edge tiles for most tile types, so I decided to add a pass after map generation to add these cosmetic overlays appropriately to the procedural terrain.
Conceptually, this is just a very specific cellular automata problem. However, because this tileset was missing an edge for every configuration (for instance, a grass tile with only one neighboring grass tile), I couldn't just set the rule for every configuration - there would definitely be invalid tiles on the map, and I'd have to deal with them somehow.. Additionally, I needed a way to determine which edge to place between tile types - should the grass edge go on the sand tile, or should the sand edge go on the grass tile? What about areas where three different tile types meet on one space?
The first step is to establish what kind of edge a tile should have on it. In data, I defined a terrain height for all terrain tiles, and use that to determine which direction an edge should "flow". So now I could know in data, that between grass and sand, grass edges should go on top of sand tiles. Now, for each tile, I can look at the neighboring tiles, and establish what higher-level edge is most common to determine the edge type. Once I know what kind of edge to place, I can look at a set of rules to determine which edge should be placed - or at least, which one is most suitable.
<TileDefinition name="Grass" spriteCoords="6,31|7,31|7,31|8,31|8,31|8,31|8,31|8,31" chromaKey ="0,255,0" allowsSight="true" allowsWalking="true" allowsFlying="true" allowsSwimming="false" isTerrain="true" terrainHeight="4" edgeDefinition="Grass" terrainLayer="Ground" groundLayer="Grass" /> <TileDefinition name="Flowers" spriteCoords="18,0|18,0|19,0" chromaKey ="255,255,0" allowsSight="true" allowsWalking="true" allowsFlying="true" allowsSwimming="false" isTerrain="true" terrainHeight="4" terrainDefinition="Grass" edgeDefinition="Grass" terrainLayer="Ground" groundLayer="Grass" /> . . .
Now that I could find an edge to place, I had to plan for situations where there was no clear, single answer for the best edge. I decided to prioritize by the type of terrain, and have a separate sprite layer for each type - edges between ground and water/lava should be highest priority, because there is a gameplay difference between water and ground. After that, it looked best to have the grass layer be on top of any other terrain, regardless of whether it was sand or dirt. The third layer are all of the low priority edges between different types of dirt or sand - nothing necessarily looks out of place if these layers are swapped around, and small inaccuracies in the placement of edges in this layer are pretty unnoticable. To try and minimize this slim chance of strange looking tiles, I decided to add an initial pass to clear invalid configurations, so that the map started out as clean as possible.
So, my pass for edging tiles ended up looking like this:
- Clear Invalid Tiles
- Add "Tufts" where there are single high-level tiles entirely surrounded by lower-level tiles. (i.e., a single patch of grass)
- Add Ground Layer->Water Layer and Ground Layer->Lava Layer edges
- Add Grass Layer->Earth Layer edges
- Add Earth Layer->Earth Layer edges according to terrain height
Quest System
It was important to me to add a robust quest system to the game, to really get the feel of an RPG. The game has both main quests and side quests, where completing the main quest will progress the player to the next encounter, and completing side quests will grant the player various rewards, if completed. Quests have 3 components: Quest steps, Quest giver, and Quest Reward.
bool Quest::UpdateAndCheckIfComplete() { if (!m_isComplete){ //if you haven't already completed this quest, check the steps bool allComplete = true; for (int i = 0; i < m_conditions.size(); i++){ VictoryCondition* condition = m_conditions[i]; if (!condition->m_complete){ //if the condition has not already been completed if (!condition->CheckIfComplete()){ //updates and checks for completion allComplete = false; } else { if (m_questGiver != nullptr){ //update the quest giver, if the quest was given by an actor. m_questGiver->AdvanceQuest(); } if (m_definition->m_isSequential){ //if the quest should be completed in order, unlock the next step in the quest (if there is one) if (i + 1 < m_conditions.size()){ condition->m_active = false; m_conditions[i + 1]->m_active = true; } } } } } if (allComplete){ CompleteQuest(); } return allComplete; } return m_isComplete; }
The quest steps are a series of conditions, which are updated every frame. These conditions can be killing a specified actor type, collecting an item, or speaking to an actor. Every frame, the game checks if any active quest steps have been completed, and advances the quest if they have. Once all steps have been finished in a quest, the quest reward is distributed. Quest steps, called “VictoryConditions” in code, are a pure virtual class, and all of the unique quest functionalities inherit from that class.
The Quest Giver is how the quest is started – now, the quest giver is either “none” (the player starts with the quest information) or an actor of a specified type. If the quest giver is an actor, the map will spawn an actor of that type on the map, and assign the quest to that actor. The player can then talk to the actor to learn more about the quest, and progress the quest.
class QuestReward{ public: QuestReward(){}; QuestReward(tinyxml2::XMLElement* questRewardElement) {}; virtual void GiveReward(Quest* quest) = 0; static QuestReward* CreateQuestReward( const tinyxml2::XMLElement* conditionElement); }; class QuestReward_Item : public QuestReward{ public: QuestReward_Item(const tinyxml2::XMLElement* questRewardElement); void GiveReward(Quest* quest) override; ItemDefinition* m_itemToGive; }; class QuestReward_Stats : public QuestReward{ public: QuestReward_Stats(const tinyxml2::XMLElement* questRewardElement); void GiveReward(Quest* quest) override; Stats* m_statsToGive; }; class QuestReward_Ally : public QuestReward{ public: QuestReward_Ally(const tinyxml2::XMLElement* questRewardElement); void GiveReward(Quest* quest) override; //assumes that the actor to add to the party is the quest's giver };
The quest reward is a triggered once all steps in the quest have been completed. QuestReward is a pure virtual class, which individual rewards inherit from. Each child class implements it's specific functionality, including how to give the player the reward for that kind of quest - currently quests can award items, permanent stat increases, or party members. This architecture allows the quest rewards to be stored ambiguously as a QuestReward* within any QuestDefinition, but maintains the correct functionality when a quest is completed.
Back To Top
Party System
In each encounter, the player can complete a special side-quest to gain an ally in their journey. Allies spawn with a quest near villages, and send the player on lengthy missions. Once you’ve completed the quest, the ally will join your party, and fight with you. The player can swap between controlling members of their party, and can equip any member of the party with equipment.
//In gameplay, the player can swap by pressing '[' or ']' (which calls this function with swapDirection as -1 or +1) void Party::SwapPlayer(int swapDirection) { //update the current player int size = m_partyMembers.size(); //increment player index - add size to keep it >0 for mod m_currentPlayerIndex = (m_currentPlayerIndex + swapDirection + size) % size; Actor* oldPlayer = m_currentPlayer; m_currentPlayer = m_partyMembers[m_currentPlayerIndex]; //set the new player m_currentPlayer->m_isPlayer = true; oldPlayer->m_isPlayer = false; //update all party members to be following the new player for (Actor* actor : m_partyMembers){ actor->SetFollowTarget(m_currentPlayer); } }
In code, the player’s party is made up of a list of Actor entities, with a pointer to the current controlled actor, and an index for where that actor is in the array. Switching between party members is as simple as incrementing that index, and modding the result to loop through the list. The player’s inventory is shared across all party members – whenever an actor joins the party, their entire inventory is added to the party. This system allows for any number of actors to join the party, and easily distribute equipment as the player sees fit. Though, for gameplay purposes, the number of party members should be limited.
Quest Dialogue
Future Plans
Adventure is a broad game, and has lots of room to grow. I plan on continuing to work on it throughout my time at guildhall, eventually polishing it into a finished game. In the immediate feature, I'm looking to accomplish the following tasks:
- Save system
- Melee combat
- Character creation
- Ally dialogue generation
- Timed encounters
- Tutorial level
- Thematic elements
My final vision for adventure is a rogue-like game modeled after the "Stolen Century" arc in the popular dungeons and dragons podcast, "The Adventure Zone." In the arc, the players are pulled between parallel universes by a mysterious power, and are constantly pursued by an evil, enigmatic force hunting for that power. In Adventure, I will try to foster that sense of mystery by bringing the player into a new world in each encounter, each with its own characters and quests to explore. I believe that a stronger main arc for each encounter (i.e., timed encounters, a "homebase" for the player in each world, etc.) would add greatly to the player experience in adventure.


register user /
modify password
/
delete user
user
password
password confirm
delete password
delete password confirm
register


Mozadvertisers website, I developed this website for a Digital marketing agency, to showcase their services, and provide information about their agency
JK electrotecnic website, with the purpose of showing the companies services and products and provide useful information using my creativity.
JK electrotecnic website, with the purpose of showing the companies services and products and provide useful information using my creativity.
JK electrotecnic website, with the purpose of showing the companies services and products and provide useful information using my creativity.
JK electrotecnic website, with the purpose of showing the companies services and products and provide useful information using my creativity.


Yes
No
Message:
Send


You have reached the: Downloads Page -- please check back or contact us for the correct download link


|
| static void | main (String[] args) |
| |
◆ Controller()
Constructor for the Controller. Makes all the necessary assignments and sets up callbacks on the GUI components.
- Parameters
-
◆ getCurrentGameType()
| GAME_TYPE Controller.getCurrentGameType |
( |
| ) |
|
Getter for current game type
- Returns
- GAME_TYPE.STANDARD or GAME_TYPE.CUSTOM based on whether playing according to standard configuration or the custom one.
◆ getGameBoard()
◆ getGameState()
| int Controller.getGameState |
( |
| ) |
|
Getter for the current game state.
- Returns
- 0 if game is ongoing 1 if it's a checkmate -1 if it's a stalemate
◆ getPlayer1Score()
| int Controller.getPlayer1Score |
( |
| ) |
|
Getter for player1Score
- Returns
- player 1's current score
◆ getPlayer2Score()
| int Controller.getPlayer2Score |
( |
| ) |
|
Getter for player2Score
- Returns
- player 2's current score
◆ isPlayer1Turn()
| boolean Controller.isPlayer1Turn |
( |
| ) |
|
Getter for isPlayer1Turn boolean.
- Returns
- Boolean signifying whether it is player1's turn or not.
◆ main()
| static void Controller.main |
( |
String [] |
args | ) |
|
|
static |
Runner for the Chess Game.
- Parameters
-
| args | Command line arguments |
◆ setCurrentGameType()
| void Controller.setCurrentGameType |
( |
GAME_TYPE |
currentGameType | ) |
|
Setter for the current game type.
- Parameters
-
| currentGameType | GAME_TYPE enum type to set the current game type to. |
◆ setPlayer1Score()
| void Controller.setPlayer1Score |
( |
int |
player1Score | ) |
|
Setter for player 1's score.
- Parameters
-
| player1Score | score to set the player 1's score to. |
◆ setPlayer2Score()
| void Controller.setPlayer2Score |
( |
int |
player2Score | ) |
|
Setter for player 2's score.
- Parameters
-
| player2Score | score to set the player 2's score to. |
◆ controller
A reference to this Controller object, useful when referring to this controller inside of ActionListeners.
The documentation for this class was generated from the following file:


“In bygone days the world was a peaceful place, in which our forefathers knew not the blessings of Bile Beans … They were sound trenchermen, who called their few ailments ‘humours' or ‘vapours' and knew what peace of mind meant. Sixty years ago there was one lunatic in every six hundred people; to-day there is one in every two hundred.” — Isaac G Briggs, Epilepsy, Hysteria And Neurasthenia


Google is bringing its Smart Compose feature to Docs
The feature debuted on Gmail
by Bradly ShankarGoogle is bringing its Smart Compose feature to Google Docs.
For now, the feature is only available to domain administrators in beta, but it will eventually roll out to all users. The feature was previously available in Gmail.
With Smart Compose, users will be given suggestions on how to finish a sentence. The feature uses Google’s machine learning models, which study past writing to determine what to suggest.
Google Docs is available on the web, Android and iOS.
Via: The Verge


Transcript by Olivia Simon
Heading overseas on a business trip soon? Tackling global manners can often be a minefield.
Start brushing up on what you need to know and where- based off a selection of Forbes’ top 100 countries for business
| Country | Handshakes | How to Address? | Dress Code? | Business Cards |
|---|---|---|---|---|
| Brazil | Firm | Male: Senhor Silva (surname) |
Sharp | No Ritual |
| Canada | Firm | Male: Liam (first name) |
Sharp | No Ritual |
| USA | Firm | Male: Noah (first name) |
Sharp or casual | No Ritual |
| Country | Handshakes | How to Address? | Dress Code? | Business Cards |
|---|---|---|---|---|
| Denmark | Firm | Male: Herr Jenson (surname) |
Sharp | No Ritual |
| France | Light | Male: Monsieur Martin (surname) Female: Madame Martin (surname) |
Sharp | No Ritual |
| Germany | Firm | Male: Herr Müller (surname) Female: Frau Müller (surname) |
Sharp | No Ritual |
| Ireland | Firm | Male: Jack (first name) Female: Emily (first name) |
Sharp | No Ritual |
| Russia | Firm | Male: Gaspodin Smirnov (surname) Female: Gaspazhah Smirnov (surname) |
Sharp | No Ritual |
| Spain | Firm | Male: Señor Garcia (surname) Female: Señora Garcia (surname) |
Sharp | No Ritual |
| Sweden | Firm | Male: Lucas (first name) Female: Elsa (first name) |
Casual | No Ritual |
| Switzerland | Firm | Male: Mr. Bianchi (surname) Female: Ms. Bianchi (surname) |
Sharp | No Ritual |
| UK | Firm | Male: Mr. Smith (surname) Female: Ms. Smith (surname) |
Sharp | No Ritual |
| Country | Handshakes | How to Address? | Dress Code? | Business Cards |
|---|---|---|---|---|
| Israel | Firm | Male: Mr. Cohen (surname) Female: Ms. Cohen (surname) |
Casual |
|
| UAE | Firm | Male: Sayed Mohamed (first name) Female: Sayeda Maryam (first name) | Sharp | Right hand only |
| Country | Handshakes | How to Address? | Dress Code? | Business Cards | |
|---|---|---|---|---|---|
| Australia | Firm | Male: Jack (first name) Female: Charlotte (first name) |
Sharp | No ritual | |
| Hong Kong | Light | Male: Mr. Wong* Female: Mrs. Wong* * surname comes before given name | Sharp | Both hands | |
| India | Firm Combine with Namaste |
Male: Mr. Patel (surname) Female: Ms. Patel (surname) | Sharp |
|
|
| Japan | Light | Male: Sato san (surname) Female: Sato san (surname) | Sharp | Both hands | |
| New Zealand | Firm | Male: Mr. Smith (surname) Female: Ms. Smith (surname) | Sharp | No ritual | |
| Singapore | Firm | See below | Casual | Both hands | |
| South Korea | Light | Male: Mr. Kim* | Sharp | Both hands | |
| Taiwan | Light | Male: Mr. Tan* Female: Ms. Tan* * surname comes before given name | Sharp | Both hands |
Greetings depends on whom you’re meeting:
| Country | Is pre-business chit-chat customary? | If there is an agenda, do meetings stick to it? | Are interruptions allowed? | What kind of communication style is the norm? |
|---|---|---|---|---|
| Brazil | Yes | No | Yes | Direct |
| Canada | No | No | No | Indirect |
| USA | Minimal | No | No | Direct |
Direct Communication: You don't need to read between the lines. Communication is honest and blunt- you say exactly what you mean.
 This communication style is connected to the concept of ‘saving face’- protecting another’s honour and self esteem.
| Country | Is pre-business chit-chat customary? | If there is an agenda, do meetings stick to it? | Are interruptions allowed? | What kind of communication style is the norm? |
|---|---|---|---|---|
| Denmark | Minimal | Yes | Yes | Direct |
| France | No | Yes | No | Direct |
| Germany | Minimal | Yes | No | Direct |
| Ireland | Minimal | Yes | No | Direct |
| Russia | No | No | Yes | Indirect |
| Spain | Yes | No | Yes | Indirect |
| Sweden | Minimal | Yes | No | Direct |
| Switzerland | No | Yes | No | Direct |
| UK | Minimal | Yes | No | Direct |
| Country | Is pre-business chit-chat customary? | If there is an agenda, do meetings stick to it? | Are interruptions allowed? | What kind of communication style is the norm? |
|---|---|---|---|---|
| Israel | Yes | No | Yes | Indirect |
| UAE | Yes | No | Yes | Indirect |
| Country | Is pre-business chit-chat customary? | If there is an agenda, do meetings stick to it? | Are interruptions allowed? | What kind of communication style is the norm? |
|---|---|---|---|---|
| Australia | Minimal | Yes | No | Direct |
| Hong Kong | Yes | Yes | No | Indirect |
| India | Yes | No | Yes | Indirect |
| Japan | Yes | Yes | No | Indirect |
| New Zealand | Minimal | Yes | No | Direct |
| Singapore | No | No | Yes | Indirect |
| South Korea | Yes | No | No | Indirect |
| Taiwan | Yes | No | No | Indirect |
Follow these tips and never put a hand, fork or word out of place again.
| Country | Custom |
|---|---|
| Sweden | Look into the eyes of the person being toasted and say ‘skål’ (skohl) |
| Russia | Don’t start drinking until the first toast has been offered |
| Hong Kong | It’s rude to start eating before the host |
| UAE & India | Only the right hand should be used for eating |
| Switzerland | Cut potatoes with a fork, not a knife |
| Taiwan | It’s expected you leave some rice in your bowl |
| Denmark | It’s expected you finish everything on your plate |
| Brazil | Be prepared for lengthy meals (2+ hours for lunch) |
| South Korea | Be prepared to sing a solo karaoke number after dinner |
| UK | Be aware that tea and dinner may mean different things across countries |
Sources: ctbusinesstravel.co/uk/news/sources/business-etiquette-around-the-world-sources


--- layout: post title: How to add a place in google maps permalink: how-to-add-a-place-in-google-maps/ date: 2012-11-17 09:07:47.000000000 +08:00 categories: - google - howto tags: - add bussiness to google map - add map to google - bussiness map - google maps - google places - maps - maps tutorial - tutorial status: publish type: post published: true meta: _thumbnail_id: '566' _edit_last: '2' dsq_thread_id: '2979208940' cleaned: true ---
Did even once passed in your thoughts how Google Maps know the places like McDonald's or SM Malls right on the map?
Most people uses Google Maps on their daily lives, whether you are searching some places in the Internet or checking-in with your Android device, you are using Google Maps. But what most people don't know, is how Google know that there is a 7-11 store in front of your house.
Well the first thing is, we do not know exactly how those all stuffs gets added, but what we do know is that those business establishments who wants their customers to be able to find them can add their business place in the Google Map.
On this post, I will show you how to add a particular place in Google Maps.
Go to http://www.google.com/places/
Click the "Get started now" button
It will redirect you into a Login form for Google Account (if you have a gmail account, you can use that one)
Then you will end up in a page which is the main dashboard of your account.
There must be some prompt which will ask you to add a place, click that and you will end up with this page
Enter your location and the telephone number of your business (land line telephone number ensures that your business is actually there since landlines are semi permanent and most often not moved from place to place)
After that, Google will ask you more details about your bussiness
Fill in as much information that you can, specially the business address, since whatever you put in the address field, that is where the marker in the right map will mark the initial location.
After the marker had appeared on the map, zoom and move within the map to adjust it. Make sure you estimate the most accurate location of your business.
After that, Google might require some verification like sending a special code in your mobile number.


(declare-const a String) (declare-const b String) (assert (= (str.++ b a) (str.++ "abc" b))) (check-sat) (get-model)
To represent non-ASCII characters Z3 treats the sequence \xHH where HH are two hexa-decimal numerals (using one of the characters, 0-9, a-f, A-F) as an encoding of an 8 bit character. Furthermore, the following escape sequences correspond to their ASCII escape encodings.
| \a | \b | \f | \n | \r | \t | \v |
(define-const a String "\x0a") (define-const b String " ") (define-const c String "\n") (simplify (= a b)) (simplify (= a c)) (simplify (str.++ a b c))
| Operation | Brief description |
| (str.++ a b c) | String concatenation of one or more strings |
| (str.len s) | String length. Returns an integer. |
| (str.substr s offset length) | Retrieves substring of s at offset |
| (str.indexof s sub) | Retrieves first position of sub in s, -1 if there are no occurrences |
| (str.indexof s sub offset) | Retrieves first position of sub at or after offset in s, -1 if there are no occurrences |
| (str.at s offset) | Substring of length 1 at offset in s. |
| (str.contains s sub) | Does s contain the substring sub? |
| (str.prefixof pre s) | Is pre a prefix of s? |
| (str.suffixof suf s) | Is suf a suffix of s? |
| (str.replace s src dst) | Replace the first occurrence of src by dst in s. |
| (str.to.int s) | Retrieve integer encoded by string s (ground rewriting only). |
| (int.to.str i) | Retrieve string encoding of integer i (ground rewriting only). |
Note that (str.indexof s offset) is shorthand for (str.indexof s offset 0).
Some operations have under-specified behavior on certain arguments. Namely, (str.at s i) is unconstrained for indices that are either negative or beyond (- (str.len s) 1). Furthermore (str.substr s offset length) is under-specified when the offset is outside the range of positions in s or length is negative or offset+length exceeds the length of s.(simplify (str.++ (str.at "abc" 1) (str.at "abc" 0))) (simplify (str.indexof "abcabc" "a")) (simplify (str.indexof "abcabc" "a" 1)) (simplify (str.substr "xxabcyy" 2 3))A string cannot overlap with two different characters.
(declare-const a String) (assert (= (str.++ a "b") (str.++ "a" a))) (check-sat)Strings a, b, c can have a non-trivial overlap.
(declare-const a String) (declare-const b String) (declare-const c String) (assert (= (str.++ a b) "abcd")) (assert (= (str.++ b c) "cdef")) (assert (not (= b ""))) (check-sat)There is a solution to a of length at most 2.
(declare-const a String) (declare-const b String) (assert (= (str.++ "abc" a) (str.++ b "cef"))) (assert (<= (str.len a) 2)) (check-sat)There is a solution to a that is not a sequence of "a"'s.
(declare-const a String) (declare-const b String) (declare-const c String) (assert (= (str.++ a "ab" b) (str.++ b "ba" c))) (assert (= c (str.++ a b))) (assert (not (= (str.++ a "a") (str.++ "a" a)))) (check-sat) (get-model)Contains is transitive.
(declare-const a String) (declare-const b String) (declare-const c String) (assert (str.contains a b)) (assert (str.contains b c)) (assert (not (str.contains a c))) (check-sat)But containment is not a linear order.
(declare-const a String) (declare-const b String) (declare-const c String) (assert (str.contains a b)) (assert (str.contains a c)) (assert (not (str.contains b c))) (assert (not (str.contains c b))) (check-sat) (get-model)Any string is equal to the prefix and suffix that add up to a its length.
(declare-const a String) (declare-const b String) (declare-const c String) (assert (str.prefixof b a)) (assert (str.suffixof c a)) (assert (= (str.len a) (+ (str.len b) (str.len c)))) (assert (not (= a (str.++ b c)))) (check-sat)
| Operation | Brief description |
| (seq.unit elem) | Sequence with a single element elem. |
| (as seq.empty (Seq Int)) | The empty sequence of integers. |
| (seq.++ a b c) | Concatenation of one or more sequences. |
| (seq.len s) | Sequence length. Returns an integer. |
| (seq.extract s offset length) | Retrieves sub-sequence of s at offset |
| (seq.indexof s sub) | Retrieves first position of sub in s, -1 if there are no occurrences |
| (seq.indexof s sub offset) | Retrieves first position of sub at or after offset in s, -1 if there are no occurrences |
| (seq.at s offset) | Sub-sequence of length 1 at offset in s. |
| (seq.contains s sub) | Does s contain the sub-sequence sub? |
| (seq.prefixof pre s) | Is pre a prefix of s? |
| (seq.suffixof suf s) | Is suf a suffix of s? |
| (seq.replace s src dst) | Replace the first occurrence of src by dst in s. |
(declare-const s (Seq Int)) (declare-const t (Seq Int)) (declare-const j Int) (declare-const b Int) (assert (<= 10 (seq.len s))) (assert (<= 8 j)) (assert (< j (seq.len s))) (assert (= t (seq.++ (seq.extract s 0 j) (seq.unit b) (seq.extract s (+ j 1) (- (seq.len s) j 1))))) (push) (assert (not (= (seq.unit b) (seq.at t j)))) (check-sat) (pop) (push) (assert (not (= (seq.len s) (seq.len t)))) (check-sat) (pop) (push) (assert (not (= (seq.at s 8) (seq.at t 8)))) (assert (not (= (seq.at s 9) (seq.at t 9)))) (check-sat) (pop)
| Operation | Brief description |
| (str.to.re s) | Convert string to regular expression accepting s. |
| (str.in.re s r) | Determine if s is in the language generated by r. |
| re.allchar | The regular expression accepting every string. |
| re.nostr | The regular expression rejecting every string. |
| (re.range ch1 ch2) | The range of characters between ch1 and ch2. |
| (re.++ r1 r2 r3) | Concatenation of regular expressions. |
| (re.* r) | Kleene star. |
| (re.+ r) | Kleene plus. |
| (re.opt r) | Zero or one use of r. |
| ((_ re.loop lo hi) r) | from lo to hi number of repetitions of r. |
| (re.union r1 r2) | The union of regular languages. |
| (re.inter r1 r2) | The intersection of regular languages. |
| (seq.to.re s) | Convert sequenceto regular expression accepting s. |
| (seq.in.re s r) | Determine if sequence s is in the language generated by r. |
| (as re.all R) | The regular expression of sort R accepting every sequence. |
| (as re.empty R) | The regular expression of sort R rejecting every sequence. |
The re.range operator expects two strings each encoding a single character. For example (str.range "a" "\xff") is a valid range of characters, while (str.range "aa" "") is not associated with any specified range.
For added compatibility with CVC4's format, Z3 also accepts expressions of the form (re.loop r lo hi). Z3 understands only the meaning of these terms when lo, hi are integer numerals.
(declare-const a String) (push) (set-info :status sat) (assert (str.in.re a ((_ re.loop 1 3) (str.to.re "ab")))) (assert (= (str.len a) 6)) (check-sat) (get-model) (pop) (push) (set-info :status unsat) (assert (str.in.re a ((_ re.loop 1 3) (str.to.re "ab")))) (assert (> (str.len a) 6)) (check-sat) (pop)


{% extends "base.html" %} {% block page_specific_js %} {% endblock %} {% block content %}
On the job hunt, you often tell stories. This profile page is design to help you organize your elevator pitch and response to behavior interview questions.
A frequent indirect question asked of a job applicant is 'tell me about yourself'. Today people often have a variety of sites to help the prospective employer understand their background. These include LindedIn, Twitter and for software developers Github. [aside: If you haven't done so already, you'll want to put together a resume. There are a number of good sites for this purpose. So, this site doesn't replicate it.]
You may find it convenient to store the URL to your resume here. That way it is aggregated with related data.
{% if page_owner_p %} Add a link Delete
When you meet a new person on the job hunt, the elevator pitch allows you to convey your value proposition.
{% if page_owner_p %} Add a pitch
During the interview process in the United States, the job candidate is often asked a series of behavior question.
{% endblock %}


{% extends "layout.html" %} {% block page_title %} GOV.UK prototype kit {% endblock %} {% block content %} Andrea Authoriser Casterbridge College UKPRN:12345678 Home < < Add another subcontractor Enter a subcontractor name or UKPRN Search Search The College of Pet Welfare Limited UKPRN: 12348765 Add Added The College of Leicester UKPRN: 87651234 Add Added Save and continue {% endblock %}
Enter a subcontractor name or UKPRN


Transition follow by transition at end of script treats the second transition as action, see sample-05.fountain, noticed in HTML output
A: OK, the line begins with “!” so it should be “Action”
sample-05.fountain has the character “DOG” line identified as “dialogue”
sample-07.fountain (charade) has parenthiticals sprinkled in the dialogue, need to support this. It meakes some dialog show up as Action in the JSON stream.
Next (v0.1.0)
Add test to check to validate parse structure of each testdata/*.fountain file
Add demo of using fountain2json for creating a script report
Improve fountainfmt pretty print options
handle unlabeled title pages
Write and fountain2html
Add CSS dump option for fountain2html
Add option to render scrippets compatible HTML and CSS
Someday, Maybe
Add support for Markdown front matter for additiona metadata processing
handle general text (outside of notes, boneyard)
this could be handled like front matter in Markdown
definable heading prefixes
reports on screenplay
fountain2pdf
Completed
Write Parse(src []byte) returning a Fountain Struct and error


--- layout: component-layout title: Productivity ---
Productivity
Automate your processes by creating set of rules and presets to respond faster to the tickets.
Components :


Every weekend, we design the menu for next week. Our team makes sure that every meal is healthy, nutritious, and balanced. Every box is prepared locally using modern techniques to create fresh and flavorful dishes. Our meals are perfect for foodies, or someone whom simply wants to eat clean + healthy!
$1 donated to Efiwe a local Brown start-up non-profit for every package purchase.
All meals are prepared with Extra Virgin Olive Oil or Avocado Oil.


Comparing popular editors
| Recaf | JByteMod | Bytecode Viewer | reJ | JBE | dirtyJOE | |
|---|---|---|---|---|---|---|
| Supported file types | Class, Jar | Class, Jar | Class, Jar, APK, DEX | Class, Jar | Class | Class |
| Java 8 support | Supported | Supported | Supported | Not supported | Not supported | Supported |
| Multi-lingual support | Supported (English, needs contributors for creating others) | Supported (English + German, needs contributors for creating others) | Not supported | Not supported | Not supported | Not supported |
| Editable class attributes | All (Done from single inner-window) | All (Done from single inner-window on info tab) | Some (Changes made by compiling decompiled code) | All (Done from different points in the GUI depending on the attribute) | None (Viewable but not editable) | All (Value needs to be in constant pool) |
| Editable member attributes | All (Some abstracted away via ASM) | All (Some abstracted away via ASM) | Most (Changes made by compiling decompiled code) | Most (Edited from code view, must be value in constant pool except for access, cannot edit defaultValue, missing signature, missing certain access modifiers) | Some (Must be value in constant pool, missing signature, missing certain access modifiers) | Some (Must be value in constant pool, missing signature) |
| Edit multiple members side-by-side | Supported (Each item being edited is given its own window in the class's tab) | Not supported (Only one item is viewable at a time.) | Supported (Edit decompiled code, which shows all members) | Supported (All members displayed in style similar to BytecodeViewer's bytecode display) | Not supported (Only one item is viewable at a time.) | Not supported (Only one item is viewable at a time.) |
| Edit local variable table | Supported (Done via member list or when editing variable opcode) | Supported (Done via info tab on method selection) | Supported (Changes made by compiling decompiled code) | Not supported (Only viewable info is displayed in editor tab) | Not supported (Not viewable) | Supported (Missing signature) |
| Searchable items | Strings, constants, class names, member declarations, member references (Not all fields required for reference searches, allows more wide-scope searches. Clicking results jumps to item in editor. Multiple forms of string search) | Strings, member references (Not all fields required for reference searches, allows more wide-scope searches. Multiple forms of string search) | Not supported (Closest thing is the string dumper plugin) | Strings + Display text (Multiple forms of string search. Display search looks for text in the code editor tab.) | Not supported | Not supported |
| Configurable context menus | Supported (Options -> User Interface, order of context menu items configurable via up/down lists. Items can be removed entirely via config file) | Not supported | Not supported | Not supported | Not supported | Not supported |
| Auto-generated stack-frames | Supported (ASM will generate proper frames for you as long as your edits pass verification guidelines) | Supported (Max's computed on save, frames generated by right clicking class -> tools -> regenerate frames) | Supported (Changes made by compiling decompiled code) | Not supported | Not supported | Not supported |
| In-editor help | Some (Jump opcode logic optionally displayed in-editor) | Some (Tooltips for opcodes and a few input fields) | None | None | Some? (Help button does not seem to work in windows 8+) | Lots (Has mini-wiki embedded in help menu, contains opcode details and tool usage) |
| Label editing | Supported (Opcodes using labels can select from a dropdown of all labels in the method. New labels can be created.) | Supported (Opcodes using labels can select from a dropdown of all labels in the method) | Supported (Changes made by compiling decompiled code) | Not supported | Supported (Edited as plain-text opcode display) | Kinda supported (Edit opcodes with labels with hex-editing. Not exactly easy compared to others) |
| Control flow highlighting | Supported (Selecting a jump / switch opcode shows potential destinations. Selecting a label shows where it is referenced) | Not supported (But it does have a flow grapher in a separate tab) | Not supported | Not supported | Not supported | Not supported |
| Decompiler | Supported (CFR decompiler, can decompile entire classes or single methods) | Supported (Procyon / Fernflower / CFR decompilers, does entire classes) | Supported (Procyon / CFR / JD-GUI / FernFlower / Krakatau / Smali / Bytecode / Hex decompilers, does entire classes) | Not supported | Not supported | Not supported |
| Edit bytecode as decompiled code | Supported (The context menu of decompiled code has an option for recompilation) | Not supported | Supported (Control + S to save changes in current editor window) | Not supported | Not supported | Not supported |
| Plugin API | Supported (See: Plugins) | Supported | Supported (See: their docs page) | Not supported | Not supported | Not supported |
| Edit bytecode of running java processes | Supported (From the navbar select Injection->JVM list and choose a VM. Opens a new recaf instance in that process.) | Not supported | Not supported | Not supported? (Can set breakpoints in code editor, does not affect saved output. Can't find usage of it otherwise.) | Not supported | Not supported |
Note: If at any point these points become outdated or if I've made a mistake contact me (contact info on my github profile) If you don't see a feature in this table it is probably supported by all of them in some way or another.
Specifics
Now here is a specific set of useful features. Not organized in any way (I need to get on that...)
- Edit opcode-specific data
- Editing existing opcodes shows a set of similar ones. For instance, editing an InvokeVirtual shows:
- InvokeVirtual
- InvokeSpecial
- InvokeStatic
- InvokeInterface
- Other opcode-specific data is also presented. Values are updated instantaneously upon change.
- Insert new opcodes
- Opcodes are sorted into groups. Select the group related to the opcode you want to insert and a second dropdown containing the specific opcodes will appear. These groups all share the same values, so they will also appear below the opcode dropdown.
- Save and load blocks of opcodes
- Display local variable
- When editing variable-related opcodes data from the local variable table (If available) is displayed for convienence.
- Syntax highlighting
- Opcodes are bolded and additional information is color coded. You are able to change the colors through rcstyle.json
- Search for declarations/references of/to strings, fields, methods, and classes
- When given the option, searches are case insensitive by default. Searching for "aa" will show results for "AA" and "aAaA" for instance.
- Searching for references does not require all fields to be entered. This allows you to search for all references to a class, or all references to any member of a given name or type.
- Inline jump logic hints
- Next to all jump opcodes is a representation of their logic. These can be disabled in the options menu/file.
- Label editing
- Labels are a part of a few opcode groups and method attributes (jumps, switches, try-catch). Labels in a method are given arbitrary names based on their position.
- Control flow highlighting
- Control flow (Jumps and switches) have their destinations color coded. For jumps, green is the destination of a successful jump. Red for failure. For switches, yellow are the potential destinations, red is the default destination. You can also select a label to check where it is referenced.
- Examples:
- Jump to jump opcode destinations
- Open method/field declaration from reference in opcodes
- Decompile with CFR
- Automate tasks with plugin API
- Attach to running java processes


session_form.ws3
# This example shows how persistent sessions can be stored
# on the server.
# It shows two HTML forms which have one input field each.
# You can switch between these two forms using the submit
# buttons. All data given in the form
# Define a memory context to hold some configuration variables.
# The next statement makes a context called 'config' to hold
# these data. It is a cleaner way than making global variables
# because it declares them clearly to be configuration vars.
web::context config
# Now set some configuration variables. Usually put the session
# state files in a directory not accessible through the Web server.
config::cset stateDirectory /tmp/websh/state/
# Create a file counter that generates the session ids. We take
# here an easy number generator, which produces sequential numbers
# and stores the actual counter value in a file (only create one if
# the current interpreter does not already have one)
if {![llength [info commands idGenerator]]} {
web::filecounter idGenerator -filename [file join [config::cget stateDirectory] counter]
}
# Create a file context named 'state'. The option '-path' defines
# where the session contexts are stored. '-attachto' defines an
# URL parameter name that might contain an existing session.
# (This parameter name could in fact be extracted using
# 'web::param sid' whenever the session is initalized.)
web::filecontext state -path [file join [config::cget stateDirectory] %s] -attachto sid -idgen "idGenerator nextval"
# Make sure the session state directory exists
catch {file mkdir [config::cget stateDirectory]}
proc form {page code} {
# Produces a HTML FORM tag. Nested form variables must be output
# in 'code'.
# The 'page' parameter describes the web::command to call when
# the form is submitted.
web::put "<title>Session Example</title>"
web::put ""
# form starts here
web::put "<form method=\"POST\" action=\"[web::cmdurl $page]\">"
uplevel $code
web::put "</form>"
web::put ""
}
proc putErrorMessage {msg} {
# emit an error message in red.
web::put "
[web::htmlify $msg]
"
}
proc pageOne {{errorMessage ""}} {
# Display page one of our HTML form.
form processPageOne {
if {[string length $errorMessage]} {
putErrorMessage $errorMessage
}
web::put "Numbers only: <input type=\"text\" name=\"a\" value=\"[web::htmlify [state::cget a]]\">"
web::put "<input type=\"submit\" value=\"Page 2\">"
}
}
proc pageTwo {{errorMessage ""}} {
# Display page two of our HTML form.
form processPageTwo {
if {[string length $errorMessage]} {
putErrorMessage $errorMessage
}
web::put "Not empty: <input type=\"text\" name=\"b\" value=\"[web::htmlify [state::cget b]]\">"
web::put "<input type=\"submit\" value=\"Page 1\">"
}
}
proc saveAllFields {} {
# Save all form fields to state context.
# web::formvar without parameters returns a list of HTML form
# variables sent to this script. web::formvar with the name
# of a field returns its value, if the field does not exist
# it returns an empty list (or an optional 2nd parameter 'default
# value').
# For clarity, we do not handle multiple fields with the same
# name correctly here. If a HTML field is given twice or more
# 'web::formvar -count <fieldname>' would give us the field count
# 'web::formvar <fieldname>' returns then a list of n values.
foreach field [web::formvar -names] {
state::cset $field [web::formvar $field]
}
}
# Define two dispatched commands to each show one page of the
# (mini) form. The names of theses application commands will
# be used in the submit action of the form with 'web::cmdurl'.
web::command processPageOne {
state::init
if {![regexp {^[0-9]+$} [web::formvar a]]} {
# The input field does not contain only digits, so show page one again
# including an error message.
pageOne "Please enter a number."
} else {
# Everything ok, so save the form field to persistant session
# and proceed with page two.
saveAllFields
state::commit
pageTwo
}
}
web::command processPageTwo {
state::init
if {![string length [web::formvar b]]} {
# The input field is empty, so show page two again
# including an error message.
pageTwo "Please fill in field."
} else {
# Everything ok, so save the form field to persistant session
# and proceed with page one.
saveAllFields
state::commit
pageOne
}
}
# Define the default command to show page one.
web::command default {
# Initialize a fresh state.
state::init
# Show page one initially.
pageOne
}
# Dispatch to one of the web::commands according to a parameter in the
# URL. This parameter was set using 'web::cmdurl' in the FORM tag in
# procedure 'form'.
# At the very beginning we don't have a command in the URL. Then the
# web::command default is called.
# The '-track' parameter is used to take over the URL parameter 'sid'
# from "incoming" URLs to "outgoing" URLs. This parameters holds
# the session id and makes a session survive
# web::dispatch processes the URL - i.e. extracts parameters from the
# URL - and handles HTML form input sent to this script.
web::dispatch -track sid
# cleanup state (so we have no session crosstalk)
state::delete
Generated by GNU enscript 1.6.3.


assert/[1,2]
assert/1 adds a clause to a procedure
assert/2 adds a clause to a procedure
asserta/1 adds a clause at the beginning of a procedure
asserta/2 adds a clause at the beginning of a procedure
assertz/1 adds a clause at the end of a procedure
assertz/2 adds a clause at the end of a procedure
FORMS
assert(Clause)
assert(Clause,Ref)
asserta(Clause)
asserta(Clause,Ref)
assertz(Clause)
assertz(Clause,Ref)
DESCRIPTION
The Clause is added to the procedure with the same name and arity in the module that assert is called from. All uninstantiated variables are re-quantified in the clause
before it is added to the database, thus breaking any connection between the
original variables and those occurring in the clause in the database. Because of
this behavior, the order of calls to assert is important. For example, assuming
no clauses already exist for p/1, the first one of the following goals will fail, while the second succeeds.
?- X = a, assert(p(X)), p(b).
no.
?- assert(p(X)), X = a, p(b).
X = a
yes.
The placement of a clause by assert/1 is defined by the implementation. asserta/1 always adds its clause before any other clauses in the same procedure, while assertz/1 always adds its clause at the end. Each form of assert can take an optional
second argument (normally an uninstantiated variable) which is the database
reference corresponding to the clause that was added. :/2 can be used to specify in which module the assert should take place. The
database reference argument is normally passed as an uninstantiated variable.
EXAMPLES
The following example shows how the different forms of assert work:
?- assert(p(a)), asserta(p(c)), assertz(p(b)).
yes.
?- listing(p/1).
% user:p/1
p(c).
p(a).
p(b).
yes.
Notice that the order of the clauses in the database is different than the
order in which they were asserted. This is because the second assert was done with asserta/1, and the third assert was done with assertz/1. The asserta/1 call put the p(c) clause ahead of p(a) in the database. The assertz/1 call put p(b)at the end of the p/1 procedure, which happens to be after the p(a) clause. The next example demonstrates the use of parentheses in asserting a
rule into the Prolog database:
?- assertz((magic(X):- wizard(X); pointGuard(X,lakers))).
X = _1
yes.
?- listing(magic/1).
% user:magic/1
magic(_24) :-
wizard(_24)
; pointGuard(_24,lakers).
yes.
If the extra parentheses were not present, the Prolog parser would print the
following error message:
assertz(magic(X) :- wizard(X) ; pointGuard(X,lakers)).
^
Syntax Error:Comma or right paren expected in argument list.
The next example shows how the assert predicates can be used with modules. The first goal fails because there is no
module named animals. After the module is created, the assertion is successful as you can see by
looking at the listing of the animals module.
?- animals:assert(beast(prolog)).
no.
?- [user].
Consulting user.
module animals.
endmod.
user consulted.
yes.
?- animals:assert(beast(prolog)).
yes.
?- listing(animals:_).
% animals:beast/1
beast(prolog).
yes.
The following example shows the effects of adding clauses to procedures which
are part of the current goal:
?- assert(movie(jaws)), movie(X), assert(movie(jaws2)).
X = jaws;
no.
The reason this didnt work is an implementation issue. The following is the
sequence of events illustrating what happened:
First the assert(movie(jaws)) subgoal was run, causing a new procedure to be placed in the Prolog database.
When the subgoal movie(X) was run, no choice point was created because there
were no other clauses to try if failure occurred.
After movie(X) succeeded, the second clause of movie/1 was asserted, and the
initial goal succeeded, binding X to jaws.
Backtracking was initiated by the ; response to the solution, but no second
solution was found for movie/1, even though there was a solution to be found.
This was because there was no choice point to return to in movie/1.
One of the interesting (and possibly bad) parts to this phenomenon is that the
second time this goal is run it will backtrack through the clauses of movie/1. This is shown below:
?- listing(movie/1).
% user:movie/1
movie(jaws).
movie(jaws2).
yes.
?- assert(movie(jaws)), movie(X), assert(movie(jaws2)).
X = jaws;
X = jaws2;
X = jaws;
X = jaws2;
X = jaws2;
X = jaws2
yes.
The reason for this, is that there was more than one clause for movie/1 in the database this time, so a choicepoint was created for the movie(X) subgoal. Incidentally, this goal would continue finding the
X = jaws2
solution. This is because every time the movie(X) finds a new solution, it succeeds, thus causing the
assert(movie(jaws2))
subgoal to run. This adds another clause to the database to be tried when the
user causes backtracking by pressing semicolon (;). If you look at the
conversation with the Prolog shell shown above, you will notice that the last solution
was accepted because no ; was typed after it.
ERRORS
Clauses must be either structured terms or atoms. If clause is a rule, with a
principal functor of :-/2, then the head and all the subgoals of the clause must either be atoms or
structured terms.
NOTES
ALS Prolog provides a global variable mechanism separate from the Prolog
database. Using global variables is much more efficient than using assert and retract.
SEE ALSO
:/2,
[Bowen 91, 7.3], [Clocksin 81, 6.4], [Bratko 86, 7.4], [Sterling 86, 12.2].


3 injured in Houston concert stampede
Musician Travis Scott hosted a music festival
by Amir Vera, CNN(CNN) - Three people were trampled and hospitalized Saturday as thousands rushed to get into musician Travis Scott's music festival in Houston.
An Instagram video posted by the "Sicko Mode" rapper showed fans climbing over fences and a large crowd knocking down a barricade to get to the Astroworld festival.
Three people were sent to the hospital with leg injuries as they attempted to enter the festival that was expected to draw at least 50,000 people, the Houston Fire Department told CNN affiliate KTRK-TV.
Police tweeted at least one person was arrested at the festival for public intoxication, adding that they were successfully working together to "support Houston's biggest music festival." The sold-out event continued as planned Saturday.


Medis 2 Terms of Service
Last Updated: April 3, 2023
Please read these Terms of Service ("Terms", "Terms of Service") carefully before using the Medis 2 application ("Medis 2", "App") available on macOS ("Platform") accessible at the provided website or application store.
Your access to and use of Medis 2 is conditioned on your acceptance of and compliance with these Terms. These Terms apply to all users who access or use Medis 2.
By accessing or using Medis 2, you agree to be bound by these Terms. If you disagree with any part of the Terms, then you may not access or use Medis 2.
1. License
Subject to your compliance with these Terms and payment of the applicable one-time fee, the developers of Medis 2 ("Developers") grant you a non-exclusive, non-transferable, and perpetual license to access and use Medis 2 for your personal or commercial use on your macOS devices. Each license key is valid for use by one user only and can be registered on the maximum number of devices as stated during the purchase of the license. You don't need to renew the license or make any further payments to use new features or upgrade to new versions.
2. Platform Compatibility
Medis 2 is designed and developed to operate exclusively on the macOS platform. The App is not compatible with other platforms, including but not limited to, Windows and Linux. The Developers are not responsible for any issues arising from attempts to use Medis 2 on unsupported platforms.
3. Restrictions
You agree not to, and will not permit others to:
- Modify, make derivative works of, disassemble, reverse compile, or reverse engineer any part of Medis 2.
- Remove, alter, or obscure any proprietary notice (including copyright and trademark notices) of the Developers or their affiliates in Medis 2.
4. Support and Updates
The Developers may, at their sole discretion, provide technical support, updates, or bug fixes for Medis 2. Any such support, updates, or bug fixes shall be subject to these Terms.
5. Disclaimer of Warranty
Medis 2 is provided on an "AS IS" and "AS AVAILABLE" basis. The Developers disclaim all warranties of any kind, whether express or implied, including but not limited to implied warranties of merchantability, fitness for a particular purpose, or non-infringement.
6. Limitation of Liability
In no event shall the Developers, their licensors, or any of their affiliates be liable for any damages (including, without limitation, lost profits, lost data, or loss of use) arising out of or in connection with the use or inability to use Medis 2 or these Terms, including but not limited to any claims based on contract, tort, or any other legal theory, even if such party has been advised of the possibility of such damages.
7. Governing Law
These Terms shall be governed and construed in accordance with the laws of the jurisdiction in which the Developers are located, without regard to its conflict of law provisions.
8. Changes to Terms
The Developers reserve the right, at their sole discretion, to modify or replace these Terms at any time. If a revision is material, the Developers will make reasonable efforts to provide at least 30 days' notice prior to any new terms taking effect. What constitutes a material change will be determined at the Developers' sole discretion.
By continuing to access or use Medis 2 after such revisions become effective, you agree to be bound by the revised Terms. If you do not agree to the new Terms, you must stop using Medis 2.
9. Contact
If you have any questions about these Terms, please contact the Developers through the email medis@zihua.li.


hexo new <title>
Add a markdown file (.md
) in source/_posts
folder of your hexo project.
“Suka” not only support the option in hexo documents mentioned above, bus also support those extended front-matter below:
| Name | Description | Default Valu |
|---|---|---|
thumbnail |
The thumbnail url for post | |
toc |
Show TOC or not | true |
busuanzi_offset |
Busuanzi Offset for current page | 0 |
license |
Override the configuration in theme config for current page |


Hands-On Full Stack Development with Java EE and Angular 9
Build scalable applications with microservices backend and Angular front end
You can buy this book on Amazon or at your favourite online retailer
My Button


Hello, it is nice to meet you! My name is Daisy Johnson, I am a software developer and this is my about me page!
Fun Facts:
- I am originally from California but have lived in Montana from the age of 11, and I absolutely love it here.
- I come from a large family and have four older sisters making me the baby of the family.
- I enjoy paddle-boarding in the summertime, and staying inside and watching movies during the snowy Montana winters.
- I have earned an Associate's degree.
- I have an esthetician lisence.
- I have worked in the resturant industry.
- I have worked in the retail industry.
- I would like to eventually pursue my Bachelor's degree.
- I would like to buy my first home before I am 30.
- I want to be a successful software developer.
My Top Ten Favorite Movies!
- The Lord of the Rings (I'm counting all three as one)
- Howl's Moving Castle
- District 9
- Spirited Away
- Titanic
- Shrek 1 and 2
- Avatar
- Planet of the Apes
- Joker
- Moulin Rouge


Let's Encrypt With Let's Encrypt
What is website encryption?
As of today the pages on this site are being served up over SSL. This means that the sever this site is hosted on is encrypting each webpage before it serves it to your browser. Encryption makes the data unreadable to third parties, and also ensures that the data that you see has not been tampered with.
An encrypted website can be identified by the https:// as opposed to the http:// at the beginning of the address bar, and a (usually green) lock icon just to the left of the actual address text. The state of the lock icon also serves to warn against possible faults in the encryption. In Google Chrome, a red lock icon and https being stricken out indicates a serious fault in the SSL on the site (either the encryption is broken or the identity of the host has not been verified). An orange lock icon is less severe, and typically indicates that domain may be encrypted but some of the elements on the page are not.
As a rule of thumb, if the connection is not in the “green” status, you should never enter sensitive data (credit card numbers, SSNs, personal info) anywhere on the site. Other browsers such as Firefox may not adhere to this same color system for indicating whether SSL is working on a site, but you can always click the lock icon for more information about the encryption status. This should be true for all browsers on all operating systems.
How is this site encrypted?
Quite a while ago, an organization called Let’s Encrypt was created to serve as a new certificate authority. A certificate authority serves as a trusted, unbiased organization that independently verifies the authenticity of servers that want to serve encrypted web content to a browser.
Before Let’s Encrypt, a website owner had to pay money to a certificate authority like DigiCert, Comodo, or Symantec in order to get an SSL certificate. Prices of SSL certificates from these authorities are in my opinion very expensive. The cheapest one I can see is a single domain certificate from Comodo for $76 per year, ranging all the way up to a wildcard certificate (covering all of a website’s subdomains) from Symantec for a whopping $1,999 per year! For a website like this one, paying over $6 a month just to serve my visitors lightly styled HTML pages over SSL is a waste of money.
But this is where Let’s Encrypt comes back into the picture. Let’s Encrypt is a free service that is the product of a collaboration between organizations like Mozilla, Akami, Cisco, and the EFF that aims to bring free SSL certificates to the entire internet. What’s more is that Let’s Encrypt is a totally automated service, not requiring any human intervention on behalf of the certificate authority to issue a certificate for a particular host.
A couple weeks ago, I signed up to request an invite to the Let’s Encrypt beta program. The opportunity to serve my site over SSL without having to pay a ton of money (in this case, for nothing other than a bit of my time) was a good prospect to me. I did not hesitate to submit this site to participate in the beta program. Today, I got an invite.
Encryption Steps
I will not go into much detail into how the actual SSL setup process, because there really was not much to it. Anyone with a moderate amount of Linux experience should be able to follow the instructions and complete the process within 20 minutes. The email I received inviting me to the beta program contained most of the instructions for setting up SSL. In short, the steps were like this:
- Clone the
letsencrypt
client (a command line tool written in Python) from the Let’s Encrypt GitHub repo cd
into the cloned repo and run a script with./letsencrypt
and a few option flags (provided in the email)- Follow the wizard and select the domain that is to be served over SSL (based off of available Apache/Nginx configurations)
- Add a redirect from HTTP to HTTPS in my
/etc/apache2/sites-enabled/
configuration file for this domain - Ensure that none of the assets (like Disqus comments) on my site are being served over HTTP (to avoid the “orange lock” warning mentioned earlier)
Why Encrypt?
The lingering question here is quite simple: Why bother encrypting? This is just a blog website that has a relatively small amount of content. The most sensitive piece of information here is probably my email address, and the biggest risk associated with that is my inbox getting hit with spam. It is not like encryption is doing anything to mitigate that either. It would appear as though me taking any time at all to encrypt this site is utterly pointless.
But I believe that there is a reason. I am a proponent of encryption becoming a de facto standard for how we share data over the internet. Encrypted data should not just be the content your bank website sends you when you check your account balance. Nor should it be just your payment gateway connection when you click “Checkout with PayPal” on a store’s site. I believe that everything should be encrypted, all of the time. That means all communication, all transactions, all entertainment, and all information access in general.
When encryption is the standard, the discrepancy between important encrypted data (like your medical records on your hospital’s website) and unimportant data (like this blog post) vanishes. By encrypting everything, important encrypted content becomes obscured by all of the unimportant encrypted content. This makes it very difficult for a malicious entity to target important encrypted data. An attacker may waste time and money attempting to decrypt data exchanged between your computer and some server, only to find that the data is a sad pepe meme, for example.
The other component of my belief for encrypting everything is simply from a privacy standpoint. I believe that nobody should have the ability to track what you do on the internet, and making encryption a standard is perhaps the most important thing we can do to protect against that. This is particularly important for protecting people who are not tech savvy, and who are most likely to have their information compromised or make dangerous decisions on the internet.
Fortunately, this belief is not novel. Companies like Google and Apple are moving rapidly towards an encryption by default standard. Brucer Schneier also made a good post about the importance of encrypting everything. And as of next month, Let’s Encrypt will go public and anyone will be able to use the service to serve encrypted versions of their own website.
The bottom line is that while the decision to encrypt my website looked at in isolation seems pointless, looking at it as part of growing standard of encrypting everything paints a very different picture.