安卓魔方游戏
㈠ 有没有手机版的魔方世界
没有
但一个叫做 被尘封的故事 的游戏，极类似于minecraft和魔方世界的RPG，但是ios上好像也没有（找到了告诉我），只有安卓可以玩
㈡ 图案是眼睛,一个类似魔方的游戏，在苹果手机耍了的，是把那个眼睛拼成一条，就一个魔方，有时间限制
基本的路子和三阶魔方差不多，只是形状大小的差异。底层就用苹果的上层，因为那个块比较大，比较好辨认，还有一点就是在弄中层的时候要注意中心块的方向，因为三阶魔方的中心块是正方形，所以怎么转都一样，但是苹果魔方就不一样了，在你移动棱块的时候中心块也跟着动，你多转几次，掌握好规律就行了，顶层的四个棱块是一样大小的，这样的话用一个基本公式就可以了。三阶魔方弄好了，这个没问题的。静下心来多试几次，加油！相信你可以的！
㈢ 在手机上玩摩方，有吗
我在手机玩过这个游戏，不过是英文版的，不过用熟练了之后也没有什么关系，你可以尝试一下，是一个3d的魔方，我在手头上没有魔方的时候会玩这个游戏，你只要在应用商店搜索魔方，可能找到如果找不到，你就从网络上搜魔方游戏安卓，然后就可以找到这个游戏。不过日常的我的话最好还是有实体的比较好，因为有利于操作，有利于观察，玩起来就是体验比手机版的更要好。而且你买一个稍微好点的，也不用花太多的钱，二三十块钱就能买到，手感不错的，所以手机版的只是在手头上没有的时候玩一玩，平常还是建议玩真正的。我在手机玩过这个游戏，不过是英文版的，不过用熟练了之后也没有什么关系，你可以尝试一下，是一个3d的魔方，我在手头上没有魔方的时候会玩这个游戏，你只要在应用商店搜索魔方，可能找到如果找不到，你就从网络上搜魔方游戏安卓，然后就可以找到这个游戏。不过日常的我的话最好还是有实体的比较好，因为有利于操作，有利于观察，玩起来就是体验比手机版的更要好。而且你买一个稍微好点的，也不用花太多的钱，二三十块钱就能买到，手感不错的，所以手机版的只是在手头上没有的时候玩一玩，平常还是建议玩真正的。
㈣ 毕业设计选了用android做一个3d魔方的游戏，应为android以前没接触过的，要从头开始学的。这个难吗高手
只要java好就没有问题，这是3D魔方android的源码。
package com.example.android.image3D;
import android.view.SurfaceView;
import android.view.SurfaceHolder;
import android.content.Context;
import android.util.AttributeSet;
import java.util.ArrayList;
import java.util.concurrent.Semaphore;
import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGL11;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.egl.EGLContext;
import javax.microedition.khronos.egl.EGLDisplay;
import javax.microedition.khronos.egl.EGLSurface;
import javax.microedition.khronos.opengles.GL;
import javax.microedition.khronos.opengles.GL10;
public class View3D extends SurfaceView implements SurfaceHolder.Callback {
private static final Semaphore sEglSemaphore = new Semaphore(1);
private boolean mSizeChanged = true;
private SurfaceHolder mHolder;
private GLThread mGLThread;
private GLWrapper mGLWrapper;
public View3D(Context context) {
super(context);
init();
}
public View3D(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
private void init() {
mHolder = getHolder();
mHolder.addCallback(this);
mHolder.setType(SurfaceHolder.SURFACE_TYPE_GPU);
}
public SurfaceHolder getSurfaceHolder() {
return mHolder;
}
public void setGLWrapper(GLWrapper glWrapper) {
mGLWrapper = glWrapper;
}
public void setRenderer(Renderer renderer) {
mGLThread = new GLThread(renderer);
mGLThread.start();
}
public void surfaceCreated(SurfaceHolder holder) {
mGLThread.surfaceCreated();
}
public void surfaceDestroyed(SurfaceHolder holder) {
mGLThread.surfaceDestroyed();
}
public void surfaceChanged(SurfaceHolder holder,
int format, int w, int h) {
mGLThread.onWindowResize(w, h);
}
public void onPause() {
mGLThread.onPause();
}
public void onResume() {
mGLThread.onResume();
}
@Override
public void onWindowFocusChanged(boolean hasFocus) {
super.onWindowFocusChanged(hasFocus);
mGLThread.onWindowFocusChanged(hasFocus);
}
public void queueEvent(Runnable r) {
mGLThread.queueEvent(r);
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
mGLThread.requestExitAndWait();
}
public interface GLWrapper {
GL wrap(GL gl);
}
public interface Renderer {
int[] getConfigSpec();
void surfaceCreated(GL10 gl);
void sizeChanged(GL10 gl, int width, int height);
void drawFrame(GL10 gl);
}
private class EglHelper {
EGL10 mEgl;
EGLDisplay mEglDisplay;
EGLSurface mEglSurface;
EGLConfig mEglConfig;
EGLContext mEglContext;
public EglHelper() {
}
public void start(int[] configSpec){
mEgl = (EGL10) EGLContext.getEGL();
mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
int[] version = new int[2];
mEgl.eglInitialize(mEglDisplay, version);
EGLConfig[] configs = new EGLConfig[1];
int[] num_config = new int[1];
mEgl.eglChooseConfig(mEglDisplay, configSpec, configs, 1,
num_config);
mEglConfig = configs[0];
mEglContext = mEgl.eglCreateContext(mEglDisplay, mEglConfig,
EGL10.EGL_NO_CONTEXT, null);
mEglSurface = null;
}
public GL createSurface(SurfaceHolder holder) {
if (mEglSurface != null) {
mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,
EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
}
mEglSurface = mEgl.eglCreateWindowSurface(mEglDisplay,
mEglConfig, holder, null);
mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,
mEglContext);
GL gl = mEglContext.getGL();
if (mGLWrapper != null) {
gl = mGLWrapper.wrap(gl);
}
return gl;
}
public boolean swap() {
mEgl.eglSwapBuffers(mEglDisplay, mEglSurface);
return mEgl.eglGetError() != EGL11.EGL_CONTEXT_LOST;
}
public void finish() {
if (mEglSurface != null) {
mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,
EGL10.EGL_NO_SURFACE,
EGL10.EGL_NO_CONTEXT);
mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
mEglSurface = null;
}
if (mEglContext != null) {
mEgl.eglDestroyContext(mEglDisplay, mEglContext);
mEglContext = null;
}
if (mEglDisplay != null) {
mEgl.eglTerminate(mEglDisplay);
mEglDisplay = null;
}
}
}
class GLThread extends Thread {
private boolean mDone;
private boolean mPaused;
private boolean mHasFocus;
private boolean mHasSurface;
private boolean mContextLost;
private int mWidth;
private int mHeight;
private Renderer mRenderer;
private ArrayList<Runnable>
mEventQueue = new ArrayList<Runnable>();
private EglHelper mEglHelper;
GLThread(Renderer renderer) {
super();
mDone = false;
mWidth = 0;
mHeight = 0;
mRenderer = renderer;
setName("GLThread");
}
@Override
public void run() {
try {
try {
sEglSemaphore.acquire();
} catch (InterruptedException e) {
return;
}
guardedRun();
} catch (InterruptedException e) {
} finally {
sEglSemaphore.release();
}
}
private void guardedRun() throws InterruptedException {
mEglHelper = new EglHelper();
int[] configSpec = mRenderer.getConfigSpec();
mEglHelper.start(configSpec);
GL10 gl = null;
boolean tellRendererSurfaceCreated = true;
boolean tellRendererSurfaceChanged = true;
while (!mDone) {
int w, h;
boolean changed;
boolean needStart = false;
synchronized (this) {
Runnable r;
while ((r = getEvent()) != null) {
r.run();
}
if (mPaused) {
mEglHelper.finish();
needStart = true;
}
if(needToWait()) {
while (needToWait()) {
wait();
}
}
if (mDone) {
break;
}
changed = mSizeChanged;
w = mWidth;
h = mHeight;
mSizeChanged = false;
}
if (needStart) {
mEglHelper.start(configSpec);
tellRendererSurfaceCreated = true;
changed = true;
}
if (changed) {
gl = (GL10) mEglHelper.createSurface(mHolder);
tellRendererSurfaceChanged = true;
}
if (tellRendererSurfaceCreated) {
mRenderer.surfaceCreated(gl);
tellRendererSurfaceCreated = false;
}
if (tellRendererSurfaceChanged) {
mRenderer.sizeChanged(gl, w, h);
tellRendererSurfaceChanged = false;
}
if ((w > 0) && (h > 0)) {
mRenderer.drawFrame(gl);
mEglHelper.swap();
}
}
mEglHelper.finish();
}
private boolean needToWait() {
return (mPaused || (! mHasFocus) || (! mHasSurface) || mContextLost)
&& (! mDone);
}
public void surfaceCreated() {
synchronized(this) {
mHasSurface = true;
mContextLost = false;
notify();
}
}
public void surfaceDestroyed() {
synchronized(this) {
mHasSurface = false;
notify();
}
}
public void onPause() {
synchronized (this) {
mPaused = true;
}
}
public void onResume() {
synchronized (this) {
mPaused = false;
notify();
}
}
public void onWindowFocusChanged(boolean hasFocus) {
synchronized (this) {
mHasFocus = hasFocus;
if (mHasFocus == true) {
notify();
}
}
}
public void onWindowResize(int w, int h) {
synchronized (this) {
mWidth = w;
mHeight = h;
mSizeChanged = true;
}
}
public void requestExitAndWait() {
synchronized(this) {
mDone = true;
notify();
}
try {
join();
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
}
}
public void queueEvent(Runnable r) {
synchronized(this) {
mEventQueue.add(r);
}
}
private Runnable getEvent() {
synchronized(this) {
if (mEventQueue.size() > 0) {
return mEventQueue.remove(0);
}
}
return null;
}
}
}
㈤ 像乐动魔方一样的手机游戏
估计有。我在windows系统手机上都玩过，一个小游戏，安卓的肯定有
㈥ 基于android的3D魔方游戏
不好意思，还真没有
㈦ CubeCheater魔方破解 有没有安卓版的 或者有没有能帮助还原魔方的软件
这类魔方的游戏软件呢，安卓手机上面有的
不过游戏最好不要下载破解版，对手机不好的
游戏最好在应用宝上面下载，它里面的游戏是正式版本，功能完善
先打开手机上面的应用宝，然后进入软件里面，在搜索框搜索你的游戏，就可以下载安装了！
其实也可以再电脑直接给手机安装游戏的，打开PC端的应用宝，连接哈数据线，进入手机应用，找到你的游戏，就可以安装到手机
㈧ 手机游戏《乐动魔方》能在安卓手机运行吗
安卓版的就看你手机的性能了，好点的话能运行
㈨ 安卓的一款游戏，类似电脑上的魔方世界那种像素游戏，有三个职业
楼主你好。
我最近在应用宝里看见过一个游戏，不知道是不是你想要的那个。
叫做生存饥饿游戏，在应用宝里下载的这个游戏都是没有广告的。
在玩的时候特别清闲，不碍眼。
我个人就经常实用应用宝来下载游戏和应用。
感觉里面我想要的游戏基本都能搜到的。
楼主也可以试试的，主要它占内存小呀，才3兆左右。
希望能帮助到你，给个采纳吧
