def __initialize(self):
# Load data from json file
with open(self.filePath) as f:
data = json.load(f)
# Create background object
self.position = data['position']
self.scale = data['scale']
self.background = pyxie.figure(data['background']['path'])
self.background.position = vmath.vec3(self.position)
self.background.scale = vmath.vec3(self.scale)
self.showcase.add(self.background)
# Spawn all objects inside this cell
if len(data['objects']) > 0:
for obj in data['objects']:
actual_obj = self.__spawnDependOnObjectType(obj)
if actual_obj is not None:
self.objects.append(actual_obj)
# Create col box for background for check, will delete this part later
col_scale = [self.scale[0] / 2, self.scale[1] / 2, self.scale[2] / 2]
colId = p.createCollisionShape(p.GEOM_BOX, halfExtents=col_scale)
p.createMultiBody(baseMass=0,
baseCollisionShapeIndex=colId,
basePosition=self.position)
def replaceMesh(self, meshData):
self.meshName = meshData
self.mesh = pyxie.figure(meshData)
self.mesh.position = vmath.vec3(self.gameObject.transform.position)
self.mesh.rotation = vmath.quat(
helperFunction.fromEulerToQuaternion(
self.gameObject.transform.rotation))
self.mesh.scale = vmath.vec3(self.gameObject.transform.scale)
def __init__(self, centerPos, boardScale, clearStageTextScale, starScale,
buttonScale, boardPath, clearStageTextPath, whiteStarPath,
yellowStarPath, nextButtonPath, retryButtonPath, showcase,
camera, ui_manager):
# Support attribute
self.centerPos = centerPos
self.isDisable = True
self.showcase = showcase
self.camera = camera
self.ui_manager = ui_manager
self.tapped = False
# Board
self.boardScale = boardScale
self.boardPath = boardPath
self.board = graphicsHelper.createSprite(self.boardScale[0],
self.boardScale[1],
self.boardPath)
self.board.position = vmath.vec3(self.centerPos)
# Clear Stage Text
self.clearTextPos = [
self.centerPos[0], self.centerPos[1] + 170, self.centerPos[2]
]
self.clearTextScale = clearStageTextScale
self.clearTextPath = clearStageTextPath
self.clearText = graphicsHelper.createSprite(self.clearTextScale[0],
self.clearTextScale[1],
self.clearTextPath)
self.clearText.position = vmath.vec3(self.clearTextPos)
# Star
self.starScale = starScale
self.whiteStarPath = whiteStarPath
self.yellowStarPath = yellowStarPath
self.listStar = list()
# Next Button
self.nextButtonPos = [
self.centerPos[0] + 60, self.centerPos[1] - 100, self.centerPos[2]
]
self.nextButtonScale = buttonScale
self.nextButtonPath = nextButtonPath
self.nextButton = graphicsHelper.createSprite(self.nextButtonScale[0],
self.nextButtonScale[1],
self.nextButtonPath)
self.nextButton.position = vmath.vec3(self.nextButtonPos)
# Next Button
self.retryButtonPos = [
self.centerPos[0] - 60, self.centerPos[1] - 100, self.centerPos[2]
]
self.retryButtonScale = buttonScale
self.retryButtonPath = retryButtonPath
self.retryButton = graphicsHelper.createSprite(
self.retryButtonScale[0], self.retryButtonScale[1],
self.retryButtonPath)
self.retryButton.position = vmath.vec3(self.retryButtonPos)
def DisplayCurrentCompleteProgress(self):
self.sliderBarPos = [
1.4 + self.backgroundBarPos[0] - self.backgroundBarScale[0] / 2 +
(self.sliderBarScale[0] * self.percentComplete) / 2,
self.backgroundBarPos[1] - 0.7, self.backgroundBarPos[2] + 1.0
]
sliderBarPercentScale = [self.percentComplete, 1]
self.sliderBar.position = vmath.vec3(self.sliderBarPos)
self.sliderBar.scale = vmath.vec3(sliderBarPercentScale)
def __autoRePosition(self):
pos, orn = p.getBasePositionAndOrientation(self.colId)
quat = self.__autoReRotation(orn)
self.model.rotation = quat
local_v = vmath.rotate(vmath.vec3(self.col_local_pos), vmath.quat(orn))
pos_x = pos[0] - local_v.x
pos_y = pos[1] - local_v.y
pos_z = pos[2] - local_v.z
model_pos = (pos_x, pos_y, pos_z)
self.model.position = vmath.vec3(model_pos)
def __init__(self, gameObject, meshData):
super().__init__(gameObject)
self.meshName = meshData
self.showOnInspector("meshName")
self.mesh = pyxie.figure(meshData)
self.mesh.position = vmath.vec3(self.gameObject.transform.position)
self.mesh.rotation = vmath.quat(
helperFunction.fromEulerToQuaternion(
self.gameObject.transform.rotation))
self.mesh.scale = vmath.vec3(self.gameObject.transform.scale)
def __init__(self, skyboxPath, gameCamera, skyboxCamera, skyboxShowcase):
self.skyboxPath = skyboxPath
self.skybox = pyxie.figure(self.skyboxPath)
self.skybox.scale = vmath.vec3([600.0, 600.0, 600.0])
self.skybox.position = vmath.vec3([0.0, -300, 100.0])
# self.skybox.rotation = vmath.quat([ 0.7071068, 0, 0, 0.7071068 ])
self.skyboxShowcase = skyboxShowcase
self.skyboxShowcase.add(self.skybox)
self.gameCamera = gameCamera
self.skyboxCamera = skyboxCamera
def CameraOnFinal(self, player):
if player.cam.position.z < self.maxHighCam:
newPos = [
player.cam.position.x, player.cam.position.y,
player.cam.position.z + 0.1
]
player.cam.position = vmath.vec3(newPos)
if player.cam.position.y > self.minFarCam:
newPos = [
player.cam.position.x, player.cam.position.y - 0.2,
player.cam.position.z
]
player.cam.position = vmath.vec3(newPos)
player.cam.target = vmath.vec3(self.finalCamTarget)
def __autoRePosition(self): pos, orn = p.getBasePositionAndOrientation(self.colId) quat = self.__autoReRotation(orn) self.model.rotation = quat local_v = vmath.rotate(vmath.vec3(self.col_local_pos), vmath.quat(orn)) pos_x = pos[0] - local_v.x pos_y = pos[1] - local_v.y pos_z = pos[2] - local_v.z model_pos = (pos_x, pos_y, pos_z) self.model.position = vmath.vec3(model_pos) # If this character have camfollow, make camera follow it if self.camFollow: self.cam.position = vmath.vec3(pos) + vmath.vec3(self.camDis) self.cam.target = vmath.vec3(pos)
def DisplayStarRate(self, rateType):
self.leftBasePos = [
self.centerPos[0] - 90, self.centerPos[1] + 102, self.centerPos[2]
]
clearRate = -1
if rateType == UNCLEAR:
clearRate = -1
elif rateType == ONE_STAR_RATE:
clearRate = 1
elif rateType == TWO_STAR_RATE:
clearRate = 2
elif rateType == THREE_STAR_RATE:
clearRate = 3
for i in range(1, 4):
if i > clearRate:
displayStar = self.whiteStarPath
else:
displayStar = self.yellowStarPath
star = graphicsHelper.createSprite(self.starScale[0],
self.starScale[1], displayStar)
star.position = vmath.vec3([
self.leftBasePos[0] + i * 45, self.leftBasePos[1],
self.leftBasePos[2]
])
self.showcase.add(star)
self.listStar.append(star)
def OnClickExcute(self, player):
linearVelocity, angularVelocity = p.getBaseVelocity(player.colId)
boostVelocity = vmath.length(vmath.vec3(linearVelocity))
if boostVelocity < 500:
boostVelocity = 500
newVelocity = [0, boostVelocity, 0]
p.resetBaseVelocity(player.colId, newVelocity, angularVelocity)
self.Hide()
def __init__(self, gameObject, colliderPath, showcase):
super().__init__(gameObject)
self.colType = "BOX COLLIDER"
self.showOnInspector("colType")
self.scale = self.gameObject.transform.scale
self.showOnInspector("scale")
self.isDisplay = True
self.showOnInspector("isDisplay")
self.showcase = showcase
self.mesh = pyxie.figure(colliderPath)
self.mesh.position = vmath.vec3(self.gameObject.transform.position)
self.mesh.rotation = vmath.quat(
helperFunction.fromEulerToQuaternion(
self.gameObject.transform.rotation))
self.mesh.scale = vmath.vec3(self.gameObject.transform.scale)
self.showcase.add(self.mesh)
def CheckDistance(self):
pos, orn = p.getBasePositionAndOrientation(self.obj.colId)
disVector = [
self.currentTargetPos[0] - pos[0],
self.currentTargetPos[1] - pos[1],
self.currentTargetPos[2] - pos[2]
]
dis = vmath.length(vmath.vec3(disVector))
if dis <= self.reverseDistance:
self.ReverseTargetPosition()
def __init__(self, pos, scale, filePath, showcase, camera, ui_manager):
self.position = pos
self.scale = scale
self.filePath = filePath
self.camera = camera
self.showcase = showcase
self.model = graphicsHelper.createSprite(self.scale[0], self.scale[1],
self.filePath)
self.model.position = vmath.vec3(self.position)
self.ui_manager = ui_manager
self.tapped = False
self.isDisable = True
def SimulateProcess(self):
index = 1
for bd in self.bodies:
if not bd:
index += 1
continue
if not self.firstTimeActive and bd not in self.activatedBodies:
index += 1
continue
pos, rot = p.getBasePositionAndOrientation(bd)
self.model.setJoint(index,
position=vmath.vec3(pos),
rotation=vmath.quat(rot),
scale=vmath.vec3(self.sizeMulti,
self.sizeMulti,
self.sizeMulti))
index += 1
if self.firstTimeActive:
self.firstTimeActive = False
def CalculateVelocity(self, pos):
direction = [
self.currentTargetPos[0] - pos[0],
self.currentTargetPos[1] - pos[1],
self.currentTargetPos[2] - pos[2]
]
normalizeDirection = vmath.normalize(vmath.vec3(direction))
newVelocity = [
normalizeDirection.x * self.move_speed,
normalizeDirection.y * self.move_speed,
normalizeDirection.z * self.move_speed
]
return newVelocity
def HandleRemovedBodies(self):
if not os.path.exists("TestVoxel/activatedBodies.pickle"):
return
with open("TestVoxel/activatedBodies.pickle", "rb") as f:
removedIndex = pickle.load(f)
self.removedBodies = removedIndex
for removedBody in removedIndex:
body = self.bodies[removedBody]
p.removeBody(body)
self.bodies[removedBody] = None
self.model.setJoint(removedBody + 1, position=vmath.vec3(0, 0, 0))
self.activatedBodies.append(body)
def __initialize(self):
for i in range(0, self.matrix_scale):
for j in range(0, self.matrix_scale):
position = self.__getPositionAndScaleOfCube(i, j)
scale = [
self.unit_scale.x / 2, self.unit_scale.y / 2,
self.unit_scale.z / 2
]
pos_v3 = vmath.vec3(position)
cube = Cube(pos_v3, self.unit_scale, self.texture_path, scale,
[0, 0, 0], [0, 0, 0, 1], True)
cube.model.rotation = vmath.quat([0, 0, 0, 1])
self.showcase.add(cube.model)
self.cube_list.append(cube)
def CheckInsideActiveRange(self, player):
player_pos, player_orn = p.getBasePositionAndOrientation(player.colId)
for bd in self.finalScene.bodies:
if not bd or bd in self.finalScene.activatedBodies:
continue
pos, orn = p.getBasePositionAndOrientation(bd)
distanceVec = [
player_pos[0] - pos[0], player_pos[1] - pos[1],
player_pos[2] - pos[2]
]
distance = vmath.length(vmath.vec3(distanceVec))
if distance < self.activeRange:
# Then activate bd
p.changeDynamics(bodyUniqueId=bd, linkIndex=-1, mass=5)
self.finalScene.activatedBodies.append(bd)
def ResetPlayer(self, player):
pos, orn = p.getBasePositionAndOrientation(player.colId)
linearVelocity, angularVelocity = p.getBaseVelocity(player.colId)
newPos = [0, 0, pos[2]]
p.resetBasePositionAndOrientation(player.colId, newPos, orn)
#Target
target = [0, 30, 2]
direction = [
target[0] - newPos[0], target[1] - newPos[1], target[2] - newPos[2]
]
multiVelocity = vmath.length(vmath.vec3(linearVelocity))
self.finalVelocity = newVelocity = [
direction[0] * multiVelocity * 0.05,
direction[1] * multiVelocity * 0.05,
direction[2] * multiVelocity * 0.05
]
p.resetBaseVelocity(player.colId, newVelocity, angularVelocity)
def _create_device_objects(self):
self.camera = pyxie.camera('2dcamera')
self.camera.orthographicProjection = True
self.camera.position = pyvmath.vec3(0, 0, 1)
self.camera.screenScale = (1, -1)
w, h = pyxie.viewSize()
self.camera.screenOffset = -w, h
gen = pyxie.shaderGenerator()
gen.setColorTexture(True)
gen.setVertexColor(True)
self.editableFigure = pyxie.editableFigure('font')
self.editableFigure.addMaterial("mate01", gen)
self.editableFigure.setMaterialParam("mate01", "DiffuseColor",
(1.0, 1.0, 1.0, 1.0))
self.editableFigure.setMaterialRenderState("mate01", "blend_enable",
True)
self.editableFigure.addJoint('joint')
self.showcase = pyxie.showcase('imgui')
self.showcase.add(self.editableFigure)
def ConstructPybulletProcess(self):
boxinfo = []
with open("TestVoxel/boxinfo.pickle", "rb") as f:
boxinfo = pickle.load(f)
self.bodies = []
box1 = boxinfo[0]
SCALE = 0.98
shape = p.createCollisionShape(p.GEOM_BOX,
halfExtents=[
self.size / 2 * SCALE,
self.size / 2 * SCALE,
self.size / 2 * SCALE
])
for data in self.newBoxData:
quat = [0.7071068, 0, 0, 0.7071068]
vec = [
data[0] - self.center[0], data[1] - self.center[1],
data[2] - self.center[2]
]
newVec = vmath.rotate(vmath.vec3(vec), vmath.quat(quat))
newPos = [
newVec.x + self.center[0], newVec.y + self.center[1],
newVec.z + self.center[2]
]
body = p.createMultiBody(baseMass=0,
baseCollisionShapeIndex=shape,
basePosition=newPos)
p.changeDynamics(
bodyUniqueId=body,
linkIndex=-1,
mass=0,
linearDamping=0.4,
angularDamping=1,
restitution=0.8,
)
self.bodies.append(body)
def __init__(self, pos, backgroundBarScale, sliderBarScale, tickScale,
backgroundBarPath, sliderBarPath, tickPath, showcase):
# Supporting attribute
self.percentComplete = 0.05
self.onAlert = False
self.oneStarPercent = 0.5
self.twoStarPercent = 0.6
self.threeStarPercent = 0.8
self.isDisable = True
# Background bar
self.backgroundBarPos = pos
self.backgroundBarScale = backgroundBarScale
self.backgroundBarPath = backgroundBarPath
self.backgroundBar = graphicsHelper.createSprite(
self.backgroundBarScale[0], self.backgroundBarScale[1],
self.backgroundBarPath)
self.backgroundBar.position = vmath.vec3(self.backgroundBarPos)
# Slider bar
self.sliderBarPos = [
self.backgroundBarPos[0] - self.backgroundBarScale[0] / 2 +
(sliderBarScale[0] * self.percentComplete) / 2,
self.backgroundBarPos[1], self.backgroundBarPos[2] + 1.0
]
self.sliderBarScale = sliderBarScale
self.sliderBarPath = sliderBarPath
self.sliderBar = graphicsHelper.createSprite(self.sliderBarScale[0],
self.sliderBarScale[1],
self.sliderBarPath)
self.sliderBar.position = vmath.vec3(self.sliderBarPos)
# Tick
self.oneStarTickPos = [
self.backgroundBarPos[0] - self.backgroundBarScale[0] / 2 +
self.backgroundBarScale[0] * self.oneStarPercent,
self.backgroundBarPos[1], self.backgroundBarPos[2] + 2.0
]
self.twoStarTickPos = [
self.backgroundBarPos[0] - self.backgroundBarScale[0] / 2 +
self.backgroundBarScale[0] * self.twoStarPercent,
self.backgroundBarPos[1], self.backgroundBarPos[2] + 2.0
]
self.threeStarTickPos = [
self.backgroundBarPos[0] - self.backgroundBarScale[0] / 2 +
self.backgroundBarScale[0] * self.threeStarPercent,
self.backgroundBarPos[1], self.backgroundBarPos[2] + 2.0
]
self.tickScale = tickScale
self.tickPath = tickPath
self.oneStarTick = graphicsHelper.createSprite(self.tickScale[0],
self.tickScale[1],
self.tickPath)
self.oneStarTick.position = vmath.vec3(self.oneStarTickPos)
self.twoStarTick = graphicsHelper.createSprite(self.tickScale[0],
self.tickScale[1],
self.tickPath)
self.twoStarTick.position = vmath.vec3(self.twoStarTickPos)
self.threeStarTick = graphicsHelper.createSprite(
self.tickScale[0], self.tickScale[1], self.tickPath)
self.threeStarTick.position = vmath.vec3(self.threeStarTickPos)
# UI parts
self.showcase = showcase
def __autoReTransform(self):
self.mesh.position = vmath.vec3(self.gameObject.transform.position)
self.mesh.rotation = vmath.quat(
helperFunction.fromEulerToQuaternion(
self.gameObject.transform.rotation))
self.mesh.scale = vmath.vec3(self.gameObject.transform.scale)
restitution=0.8,
)
bodies.append(body)
# bodies = []
# for data in boxinfo:
# body = p.createMultiBody(
# baseMass=1, baseCollisionShapeIndex=shape, basePosition=data[0]
# )
# bodies.append(body)
figure = pyxie.figure("Castle_standard")
cam = pyxie.camera()
cam.position = (0, -2, 1)
cam.target = vmath.vec3(0, 0, 0)
showcase = pyxie.showcase("case")
showcase.add(figure)
FPS = 240
p.setPhysicsEngineParameter(
fixedTimeStep=1.0 / FPS,
numSolverIterations=12,
numSubSteps=3, # 8 is smooth but not sure abt performance. Lowered substeps actually raise fps
contactBreakingThreshold=0.00000002,
useSplitImpulse=0,
splitImpulsePenetrationThreshold=9999999,
enableConeFriction=0,
deterministicOverlappingPairs=0,
solverResidualThreshold=0.1,
def CheckDeath(self):
linearVelocity, angularVelocity = p.getBaseVelocity(self.colId)
velocity = vmath.length(vmath.vec3(linearVelocity))
if velocity < self.kEpsilon:
self.isDeath = True
# p.changeDynamics(self.colId, -1, mass=0)
def CameraFollow(self):
# If this character have camfollow, make camera follow it
if self.camFollow:
self.cam.position = self.model.position + vmath.vec3(self.camDis)
self.cam.target = self.model.position
def __init__(self):
super().__init__()
self.position = pm.vec3(0, 0, 0)
self.rotation = pm.vec3(0, 0, 0)
self.scale = pm.vec3(1, 1, 1)
pyxie.window(True, SCREEN_WIDTH, SCREEN_HEIGHT)
physicsClient = p.connect(p.GUI)
p.setAdditionalSearchPath(pybullet_data.getDataPath())
boxHalfLength = 0.5
boxHalfWidth = 0.5
boxHalfHeight = 0.5
segmentLength = 5
# Create dictionary to store collision
collision_objects = dict()
# PYXIE SETTING REGION
# =============================================================================================================
cam = pyxie.camera('maincam')
cam.lockon = True
cam.position = vmath.vec3(0.0, -3.0, 3)
cam.target = vmath.vec3(0.0, 0.0, 0.0)
showcase = pyxie.showcase("case01")
scale = vmath.vec3(1, 1, 1)
position = vmath.vec3(0.0, 0.0, 3)
player_col_scale = [0.1, 0.1, 1]
player_col_local_pos = [0.0, 0.0, 1.1]
player = Player(position, scale, [0, 0.7071068, 0.7071068, 0],
'asset/Sapphiart', cam, player_col_scale, player_col_local_pos,
True)
p.changeDynamics(player.colId,
-1,
linearDamping=100.0,
lateralFriction=1,
restitution=0.0)
