kandi background
Explore Kits

freegemas-gdx | Freegemas libGDX is an Android and Java desktop port | Game Engine library

 by   dsaltares Java Version: Current License: No License

 by   dsaltares Java Version: Current License: No License

Download this library from

kandi X-RAY | freegemas-gdx Summary

freegemas-gdx is a Java library typically used in Gaming, Game Engine applications. freegemas-gdx has no vulnerabilities and it has low support. However freegemas-gdx has 4 bugs and it build file is not available. You can download it from GitHub.
Freegemas libGDX is an Android and Java desktop port of Freegemas, which in turn is an open source version of the well known Bejeweled.
Support
Support
Quality
Quality
Security
Security
License
License
Reuse
Reuse

kandi-support Support

  • freegemas-gdx has a low active ecosystem.
  • It has 141 star(s) with 67 fork(s). There are 34 watchers for this library.
  • It had no major release in the last 12 months.
  • There are 0 open issues and 1 have been closed. On average issues are closed in 431 days. There are 1 open pull requests and 0 closed requests.
  • It has a neutral sentiment in the developer community.
  • The latest version of freegemas-gdx is current.
freegemas-gdx Support
Best in #Game Engine
Average in #Game Engine
freegemas-gdx Support
Best in #Game Engine
Average in #Game Engine

quality kandi Quality

  • freegemas-gdx has 4 bugs (0 blocker, 0 critical, 4 major, 0 minor) and 305 code smells.
freegemas-gdx Quality
Best in #Game Engine
Average in #Game Engine
freegemas-gdx Quality
Best in #Game Engine
Average in #Game Engine

securitySecurity

  • freegemas-gdx has no vulnerabilities reported, and its dependent libraries have no vulnerabilities reported.
  • freegemas-gdx code analysis shows 0 unresolved vulnerabilities.
  • There are 4 security hotspots that need review.
freegemas-gdx Security
Best in #Game Engine
Average in #Game Engine
freegemas-gdx Security
Best in #Game Engine
Average in #Game Engine

license License

  • freegemas-gdx does not have a standard license declared.
  • Check the repository for any license declaration and review the terms closely.
  • Without a license, all rights are reserved, and you cannot use the library in your applications.
freegemas-gdx License
Best in #Game Engine
Average in #Game Engine
freegemas-gdx License
Best in #Game Engine
Average in #Game Engine

buildReuse

  • freegemas-gdx releases are not available. You will need to build from source code and install.
  • freegemas-gdx has no build file. You will be need to create the build yourself to build the component from source.
  • freegemas-gdx saves you 1040 person hours of effort in developing the same functionality from scratch.
  • It has 2359 lines of code, 170 functions and 32 files.
  • It has medium code complexity. Code complexity directly impacts maintainability of the code.
freegemas-gdx Reuse
Best in #Game Engine
Average in #Game Engine
freegemas-gdx Reuse
Best in #Game Engine
Average in #Game Engine
Top functions reviewed by kandi - BETA

kandi has reviewed freegemas-gdx and discovered the below as its top functions. This is intended to give you an instant insight into freegemas-gdx implemented functionality, and help decide if they suit your requirements.

  • Render this sprite .
    • Returns the available solutions .
      • Initializes the mouse manager .
        • Process input text .
          • Loads a language .
            • Render this sprite .
              • Draws this sprite .
                • Convert a number to its type .
                  • Compares two Pair objects .
                    • Check if a point is clicked .

                      Get all kandi verified functions for this library.

                      Get all kandi verified functions for this library.

                      freegemas-gdx Key Features

                      Freegemas libGDX is an Android and Java desktop port of Freegemas, which in turn is an open source version of the well known Bejeweled.

                      Community Discussions

                      Trending Discussions on Game Engine
                      • Unity 3'nd Person Controller Camera Acting Weird
                      • OpenTK doesn't render the color of my triangle
                      • How to create a first-person "space flight" camera
                      • How do I make copies of a Node in Godot
                      • Coming from OO languages to C, how can I avoid circular dependencies?
                      • SpawnObject for ak(Clone) (UnityEngine.GameObject), NetworkServer is not active. Cannot spawn objects without an active server
                      • Detecting if an enemy was shot by bullet
                      • Phaser.js: How to get or remove all sprites in one scene
                      • Phaser3, Creating Rounded Rectangle, Not Staying Put Relative To Window
                      • Ursina Python Engine: Lighting, Shadows And Bloom Effects
                      Trending Discussions on Game Engine

                      QUESTION

                      Unity 3'nd Person Controller Camera Acting Weird

                      Asked 2022-Apr-08 at 23:22

                      I'm very new in Unity and Stackowerflow. If i did something wrong, please don't judge me ^^ I used Unity's TPS Controller asset for my game. In first, it worked very well. But then It broke. But i didn't do anything :( (i don't even touch scripts or prefabs). After that, i deleted asset and re-download it but it didnt work again. Here is one example from my broken scene and these are the codes from my controller. Thanks For Any Kind of Help.

                      Starter Assets Input
                      using UnityEngine;
                      #if ENABLE_INPUT_SYSTEM && STARTER_ASSETS_PACKAGES_CHECKED
                      using UnityEngine.InputSystem;
                      #endif
                      
                      namespace StarterAssets
                      {
                          public class StarterAssetsInputs : MonoBehaviour
                          {
                              [Header("Character Input Values")]
                              public Vector2 move;
                              public Vector2 look;
                              public bool jump;
                              public bool sprint;
                      
                              [Header("Movement Settings")]
                              public bool analogMovement;
                      
                      #if !UNITY_IOS || !UNITY_ANDROID
                              [Header("Mouse Cursor Settings")]
                              public bool cursorLocked = true;
                              public bool cursorInputForLook = true;
                      #endif
                      
                      #if ENABLE_INPUT_SYSTEM && STARTER_ASSETS_PACKAGES_CHECKED
                              public void OnMove(InputValue value)
                              {
                                  MoveInput(value.Get<Vector2>());
                              }
                      
                              public void OnLook(InputValue value)
                              {
                                  if(cursorInputForLook)
                                  {
                                      LookInput(value.Get<Vector2>());
                                  }
                              }
                      
                              public void OnJump(InputValue value)
                              {
                                  JumpInput(value.isPressed);
                              }
                      
                              public void OnSprint(InputValue value)
                              {
                                  SprintInput(value.isPressed);
                              }
                      #else
                          // old input sys if we do decide to have it (most likely wont)...
                      #endif
                      
                      
                              public void MoveInput(Vector2 newMoveDirection)
                              {
                                  move = newMoveDirection;
                                  Debug.Log(move.magnitude);
                                  Debug.Log(move.normalized.magnitude);
                              } 
                      
                              public void LookInput(Vector2 newLookDirection)
                              {
                                  look = newLookDirection;
                              }
                      
                              public void JumpInput(bool newJumpState)
                              {
                                  jump = newJumpState;
                              }
                      
                              public void SprintInput(bool newSprintState)
                              {
                                  sprint = newSprintState;
                              }
                      
                      #if !UNITY_IOS || !UNITY_ANDROID
                      
                              private void OnApplicationFocus(bool hasFocus)
                              {
                                  SetCursorState(cursorLocked);
                              }
                      
                              private void SetCursorState(bool newState)
                              {
                                  Cursor.lockState = newState ? CursorLockMode.Locked : CursorLockMode.None;
                              }
                      
                      #endif
                      
                          }
                          
                      }
                      
                      Third Person Controller
                      using UnityEngine;
                      #if ENABLE_INPUT_SYSTEM && STARTER_ASSETS_PACKAGES_CHECKED
                      using UnityEngine.InputSystem;
                      #endif
                      
                      /* Note: animations are called via the controller for both the character and capsule using animator null checks
                       */
                      
                      namespace StarterAssets
                      {
                          [RequireComponent(typeof(CharacterController))]
                      #if ENABLE_INPUT_SYSTEM && STARTER_ASSETS_PACKAGES_CHECKED
                          [RequireComponent(typeof(PlayerInput))]
                      #endif
                          public class ThirdPersonController : MonoBehaviour
                          {
                              [Header("Player")]
                              [Tooltip("Move speed of the character in m/s")]
                              public float MoveSpeed = 2.0f;
                              [Tooltip("Sprint speed of the character in m/s")]
                              public float SprintSpeed = 5.335f;
                              [Tooltip("How fast the character turns to face movement direction")]
                              [Range(0.0f, 0.3f)]
                              public float RotationSmoothTime = 0.12f;
                              [Tooltip("Acceleration and deceleration")]
                              public float SpeedChangeRate = 10.0f;
                      
                              [Space(10)]
                              [Tooltip("The height the player can jump")]
                              public float JumpHeight = 1.2f;
                              [Tooltip("The character uses its own gravity value. The engine default is -9.81f")]
                              public float Gravity = -15.0f;
                      
                              [Space(10)]
                              [Tooltip("Time required to pass before being able to jump again. Set to 0f to instantly jump again")]
                              public float JumpTimeout = 0.50f;
                              [Tooltip("Time required to pass before entering the fall state. Useful for walking down stairs")]
                              public float FallTimeout = 0.15f;
                      
                              [Header("Player Grounded")]
                              [Tooltip("If the character is grounded or not. Not part of the CharacterController built in grounded check")]
                              public bool Grounded = true;
                              [Tooltip("Useful for rough ground")]
                              public float GroundedOffset = -0.14f;
                              [Tooltip("The radius of the grounded check. Should match the radius of the CharacterController")]
                              public float GroundedRadius = 0.28f;
                              [Tooltip("What layers the character uses as ground")]
                              public LayerMask GroundLayers;
                      
                              [Header("Cinemachine")]
                              [Tooltip("The follow target set in the Cinemachine Virtual Camera that the camera will follow")]
                              public GameObject CinemachineCameraTarget;
                              [Tooltip("How far in degrees can you move the camera up")]
                              public float TopClamp = 70.0f;
                              [Tooltip("How far in degrees can you move the camera down")]
                              public float BottomClamp = -30.0f;
                              [Tooltip("Additional degress to override the camera. Useful for fine tuning camera position when locked")]
                              public float CameraAngleOverride = 0.0f;
                              [Tooltip("For locking the camera position on all axis")]
                              public bool LockCameraPosition = false;
                      
                              // cinemachine
                              private float _cinemachineTargetYaw;
                              private float _cinemachineTargetPitch;
                      
                              // player
                              private float _speed;
                              private float _animationBlend;
                              private float _targetRotation = 0.0f;
                              private float _rotationVelocity;
                              private float _verticalVelocity;
                              private float _terminalVelocity = 53.0f;
                      
                              // timeout deltatime
                              private float _jumpTimeoutDelta;
                              private float _fallTimeoutDelta;
                      
                              // animation IDs
                              private int _animIDSpeed;
                              private int _animIDGrounded;
                              private int _animIDJump;
                              private int _animIDFreeFall;
                              private int _animIDMotionSpeed;
                      
                              private Animator _animator;
                              private CharacterController _controller;
                              private StarterAssetsInputs _input;
                              private GameObject _mainCamera;
                      
                              private const float _threshold = 0.01f;
                      
                              private bool _hasAnimator;
                      
                              private void Awake()
                              {
                                  // get a reference to our main camera
                                  if (_mainCamera == null)
                                  {
                                      _mainCamera = GameObject.FindGameObjectWithTag("MainCamera");
                                  }
                              }
                      
                              private void Start()
                              {
                                  _hasAnimator = TryGetComponent(out _animator);
                                  _controller = GetComponent<CharacterController>();
                                  _input = GetComponent<StarterAssetsInputs>();
                      
                                  AssignAnimationIDs();
                      
                                  // reset our timeouts on start
                                  _jumpTimeoutDelta = JumpTimeout;
                                  _fallTimeoutDelta = FallTimeout;
                              }
                      
                              private void Update()
                              {
                                  _hasAnimator = TryGetComponent(out _animator);
                                  
                                  JumpAndGravity();
                                  GroundedCheck();
                                  Move();
                              }
                      
                              private void LateUpdate()
                              {
                                  CameraRotation();
                              }
                      
                              private void AssignAnimationIDs()
                              {
                                  _animIDSpeed = Animator.StringToHash("Speed");
                                  _animIDGrounded = Animator.StringToHash("Grounded");
                                  _animIDJump = Animator.StringToHash("Jump");
                                  _animIDFreeFall = Animator.StringToHash("FreeFall");
                                  _animIDMotionSpeed = Animator.StringToHash("MotionSpeed");
                              }
                      
                              private void GroundedCheck()
                              {
                                  // set sphere position, with offset
                                  Vector3 spherePosition = new Vector3(transform.position.x, transform.position.y - GroundedOffset, transform.position.z);
                                  Grounded = Physics.CheckSphere(spherePosition, GroundedRadius, GroundLayers, QueryTriggerInteraction.Ignore);
                      
                                  // update animator if using character
                                  if (_hasAnimator)
                                  {
                                      _animator.SetBool(_animIDGrounded, Grounded);
                                  }
                              }
                      
                              private void CameraRotation()
                              {
                                  // if there is an input and camera position is not fixed
                                  if (_input.look.sqrMagnitude >= _threshold && !LockCameraPosition)
                                  {
                                      _cinemachineTargetYaw += _input.look.x * Time.deltaTime;
                                      _cinemachineTargetPitch += _input.look.y * Time.deltaTime;
                                  }
                      
                                  // clamp our rotations so our values are limited 360 degrees
                                  _cinemachineTargetYaw = ClampAngle(_cinemachineTargetYaw, float.MinValue, float.MaxValue);
                                  _cinemachineTargetPitch = ClampAngle(_cinemachineTargetPitch, BottomClamp, TopClamp);
                      
                                  // Cinemachine will follow this target
                                  CinemachineCameraTarget.transform.rotation = Quaternion.Euler(_cinemachineTargetPitch + CameraAngleOverride, _cinemachineTargetYaw, 0.0f);
                              }
                      
                              private void Move()
                              {
                                  // set target speed based on move speed, sprint speed and if sprint is pressed
                                  float targetSpeed = _input.sprint ? SprintSpeed : MoveSpeed;
                      
                                  // a simplistic acceleration and deceleration designed to be easy to remove, replace, or iterate upon
                      
                                  // note: Vector2's == operator uses approximation so is not floating point error prone, and is cheaper than magnitude
                                  // if there is no input, set the target speed to 0
                                  if (_input.move == Vector2.zero) targetSpeed = 0.0f;
                      
                                  // a reference to the players current horizontal velocity
                                  float currentHorizontalSpeed = new Vector3(_controller.velocity.x, 0.0f, _controller.velocity.z).magnitude;
                      
                                  float speedOffset = 0.1f;
                                  float inputMagnitude = _input.analogMovement ? _input.move.magnitude : 1f;
                      
                                  // accelerate or decelerate to target speed
                                  if (currentHorizontalSpeed < targetSpeed - speedOffset || currentHorizontalSpeed > targetSpeed + speedOffset)
                                  {
                                      // creates curved result rather than a linear one giving a more organic speed change
                                      // note T in Lerp is clamped, so we don't need to clamp our speed
                                      _speed = Mathf.Lerp(currentHorizontalSpeed, targetSpeed * inputMagnitude, Time.deltaTime * SpeedChangeRate);
                      
                                      // round speed to 3 decimal places
                                      _speed = Mathf.Round(_speed * 1000f) / 1000f;
                                  }
                                  else
                                  {
                                      _speed = targetSpeed;
                                  }
                                  _animationBlend = Mathf.Lerp(_animationBlend, targetSpeed, Time.deltaTime * SpeedChangeRate);
                      
                                  // normalise input direction
                                  Vector3 inputDirection = new Vector3(_input.move.x, 0.0f, _input.move.y).normalized;
                      
                                  // note: Vector2's != operator uses approximation so is not floating point error prone, and is cheaper than magnitude
                                  // if there is a move input rotate player when the player is moving
                                  if (_input.move != Vector2.zero)
                                  {
                                      _targetRotation = Mathf.Atan2(inputDirection.x, inputDirection.z) * Mathf.Rad2Deg + _mainCamera.transform.eulerAngles.y;
                                      float rotation = Mathf.SmoothDampAngle(transform.eulerAngles.y, _targetRotation, ref _rotationVelocity, RotationSmoothTime);
                      
                                      // rotate to face input direction relative to camera position
                                      transform.rotation = Quaternion.Euler(0.0f, rotation, 0.0f);
                                  }
                      
                      
                                  Vector3 targetDirection = Quaternion.Euler(0.0f, _targetRotation, 0.0f) * Vector3.forward;
                      
                                  // move the player
                                  _controller.Move(targetDirection.normalized * (_speed * Time.deltaTime) + new Vector3(0.0f, _verticalVelocity, 0.0f) * Time.deltaTime);
                      
                                  // update animator if using character
                                  if (_hasAnimator)
                                  {
                                      _animator.SetFloat(_animIDSpeed, _animationBlend);
                                      _animator.SetFloat(_animIDMotionSpeed, inputMagnitude);
                                  }
                              }
                      
                              private void JumpAndGravity()
                              {
                                  if (Grounded)
                                  {
                                      // reset the fall timeout timer
                                      _fallTimeoutDelta = FallTimeout;
                      
                                      // update animator if using character
                                      if (_hasAnimator)
                                      {
                                          _animator.SetBool(_animIDJump, false);
                                          _animator.SetBool(_animIDFreeFall, false);
                                      }
                      
                                      // stop our velocity dropping infinitely when grounded
                                      if (_verticalVelocity < 0.0f)
                                      {
                                          _verticalVelocity = -2f;
                                      }
                      
                                      // Jump
                                      if (_input.jump && _jumpTimeoutDelta <= 0.0f)
                                      {
                                          // the square root of H * -2 * G = how much velocity needed to reach desired height
                                          _verticalVelocity = Mathf.Sqrt(JumpHeight * -2f * Gravity);
                      
                                          // update animator if using character
                                          if (_hasAnimator)
                                          {
                                              _animator.SetBool(_animIDJump, true);
                                          }
                                      }
                      
                                      // jump timeout
                                      if (_jumpTimeoutDelta >= 0.0f)
                                      {
                                          _jumpTimeoutDelta -= Time.deltaTime;
                                      }
                                  }
                                  else
                                  {
                                      // reset the jump timeout timer
                                      _jumpTimeoutDelta = JumpTimeout;
                      
                                      // fall timeout
                                      if (_fallTimeoutDelta >= 0.0f)
                                      {
                                          _fallTimeoutDelta -= Time.deltaTime;
                                      }
                                      else
                                      {
                                          // update animator if using character
                                          if (_hasAnimator)
                                          {
                                              _animator.SetBool(_animIDFreeFall, true);
                                          }
                                      }
                      
                                      // if we are not grounded, do not jump
                                      _input.jump = false;
                                  }
                      
                                  // apply gravity over time if under terminal (multiply by delta time twice to linearly speed up over time)
                                  if (_verticalVelocity < _terminalVelocity)
                                  {
                                      _verticalVelocity += Gravity * Time.deltaTime;
                                  }
                              }
                      
                              private static float ClampAngle(float lfAngle, float lfMin, float lfMax)
                              {
                                  if (lfAngle < -360f) lfAngle += 360f;
                                  if (lfAngle > 360f) lfAngle -= 360f;
                                  return Mathf.Clamp(lfAngle, lfMin, lfMax);
                              }
                      
                              private void OnDrawGizmosSelected()
                              {
                                  Color transparentGreen = new Color(0.0f, 1.0f, 0.0f, 0.35f);
                                  Color transparentRed = new Color(1.0f, 0.0f, 0.0f, 0.35f);
                      
                                  if (Grounded) Gizmos.color = transparentGreen;
                                  else Gizmos.color = transparentRed;
                                  
                                  // when selected, draw a gizmo in the position of, and matching radius of, the grounded collider
                                  Gizmos.DrawSphere(new Vector3(transform.position.x, transform.position.y - GroundedOffset, transform.position.z), GroundedRadius);
                              }
                          }
                      }
                      

                      ANSWER

                      Answered 2022-Apr-08 at 23:22

                      I had the same problem too. I researched a lot of documents about that and finally, I solved this problem. The problem is not about your codes or events or smth else. The problem is related to Unity. I don't know the exact reason for the problem but you can solve it this way: First, go Edit > Project Settings and select Input System Package from the Left tab. And then, change the Update Method with Process Events In Dynamic Update. And that's all! Dynamic update means the usual Update method that you see in the scripts void Update().

                      Images

                      enter image description here enter image description here

                      Source https://stackoverflow.com/questions/71804001

                      Community Discussions, Code Snippets contain sources that include Stack Exchange Network

                      Vulnerabilities

                      No vulnerabilities reported

                      Install freegemas-gdx

                      You can download it from GitHub.
                      You can use freegemas-gdx like any standard Java library. Please include the the jar files in your classpath. You can also use any IDE and you can run and debug the freegemas-gdx component as you would do with any other Java program. Best practice is to use a build tool that supports dependency management such as Maven or Gradle. For Maven installation, please refer maven.apache.org. For Gradle installation, please refer gradle.org .

                      Support

                      For any new features, suggestions and bugs create an issue on GitHub. If you have any questions check and ask questions on community page Stack Overflow .

                      DOWNLOAD this Library from

                      Find, review, and download reusable Libraries, Code Snippets, Cloud APIs from
                      over 430 million Knowledge Items
                      Find more libraries
                      Reuse Solution Kits and Libraries Curated by Popular Use Cases
                      Explore Kits

                      Save this library and start creating your kit

                      Explore Related Topics

                      Share this Page

                      share link
                      Consider Popular Game Engine Libraries
                      Try Top Libraries by dsaltares
                      Compare Game Engine Libraries with Highest Support
                      Compare Game Engine Libraries with Highest Quality
                      Compare Game Engine Libraries with Highest Security
                      Compare Game Engine Libraries with Permissive License
                      Compare Game Engine Libraries with Highest Reuse
                      Find, review, and download reusable Libraries, Code Snippets, Cloud APIs from
                      over 430 million Knowledge Items
                      Find more libraries
                      Reuse Solution Kits and Libraries Curated by Popular Use Cases
                      Explore Kits

                      Save this library and start creating your kit

                      • © 2022 Open Weaver Inc.