Форум программистов, компьютерный форум CyberForum.ru

Программирование Android

Войти
Регистрация
Восстановить пароль
 
EduardSakhnovic
0 / 0 / 0
Регистрация: 10.04.2015
Сообщений: 69
#1

Разбираю исходник игры Пакман - Android

18.09.2015, 19:27. Просмотров 299. Ответов 1
Метки нет (Все метки)

Можете мне объяснить что к чему в этом классе?Я его в своем проекте использую
Java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
package es.eduards.pacman;
import java.util.HashMap;
import java.util.Map;
 
import android.annotation.TargetApi;
import android.content.Context;
import android.media.AudioManager;
import android.media.MediaPlayer;
import android.media.SoundPool;
import android.media.SoundPool.OnLoadCompleteListener;
import android.os.Build;
import android.util.Log;
 
/**
 * The class to create sounds for the game
 */
public class SoundPlayer {
 
    private static final String TAG = "SoundPlayer";//quality parameter
   /*Sounds for Pacman(Player)*/
    private static final int[] SOUND_RESOURCES = {
            R.raw.death,
            R.raw.eating_dot_1,
            R.raw.eating_dot_2,
            R.raw.eating_ghost,
            R.raw.extra_life,
            R.raw.fruit,
 
    };
   private static final int SOUND_CHANNEL_COUNT = 5;//channel number for pacman sound display
    /*Sounds for ghosts*/
    private static final int[] AMBIENT_RESOURCES = {
            R.raw.ambient_1,
            R.raw.ambient_2,
            R.raw.ambient_3,
            R.raw.ambient_4,
            R.raw.ambient_eyes,
            R.raw.ambient_fright,
    };
    private static final int AMBIENT_CHANNEL_COUNT = 1;//channel count for ghost display
    private static final int CUTSCENE_RESOURCE_ID = R.raw.cutscene;//sound for cutscenes
 
    private final Context context;
    private SoundPoolManager soundManager;
    private boolean soundAvailable;
    private SoundPoolManager ambientManager;
    private boolean ambientAvailable;
    private AudioClip cutsceneAudioClip;
    private boolean cutsceneAmbientAvailable;
    private String queuedAmbient;
 
    /**
     * Constructor for class that builds the sound player
     * @param context
     */
    SoundPlayer(Context context) {
        this.context = context;
    }
 
    /**
     * Inits the player for playing cutscene,ambient,and Player sounds
     */
    void init() {
        cutsceneAudioClip = new AudioClip(context);//init constructor for cutscene
        soundManager =new SoundPoolManager( context,SOUND_RESOURCES, SOUND_CHANNEL_COUNT);//init constructor for pacman sounds
        ambientManager=new SoundPoolManager(context,AMBIENT_RESOURCES, AMBIENT_CHANNEL_COUNT);//init constructor for ghosts sound
        cutsceneAmbientAvailable = cutsceneAudioClip.init();//to check the availability for displaying cutscene sound
        if (cutsceneAmbientAvailable) {
            /*To check for availability of Player's sounds*/
            soundManager.init(new SoundPoolManager.AvailabilityNotifier() {
                @Override
                public void notifyAvailability() {
                    soundAvailable = true;
                    if (isAvailable()) {
                        playQueuedAmbient();
                    }
                }
            });
            /*check for the availability of ambient sounds*/
            ambientManager.init(new SoundPoolManager.AvailabilityNotifier() {
                @Override
                public void notifyAvailability() {
                    ambientAvailable = true;
                    if (isAvailable()) {
                        playQueuedAmbient();
                    }
                }
            });
        }
    }
 
    /**
     * Play the sound resources for Pacman
     * Displays sounds of
     * death
     * eating_dot_1
     * eating_dot_2
     * eating_ghost
     * extra_life
     * fruit
     *
     * @param track-one track of the above
     * @param channel-SOUND_CHANNEL_COUNT = 5
     */
   void playTrack(String track, int channel) {
       /*if sound available or not*/
        if (isAvailable()) {
            soundManager.playTrack(track, channel, false);
        }
    }
 
    /**
     * To stop channnel relates to ambient or sound resources
     * @param channel
     */
    void stopChannel(int channel) {
        if (isAvailable()) {
            soundManager.stopChannel(channel);
        }
    }
 
    /**
     * Method to play the ambient sound of ghost
     * when they move
     * ambient_1
     * ambient_2
     * etc.
     * @param track
     */
    void playAmbient(String track) {
        if (isAvailable()) {
            ambientManager.playTrack(track, 0, true);
            queuedAmbient = null;
        } else {
            queuedAmbient = track;
        }
    }
 
    /**
     * To play the next in queue ambient sound
     */
    private void playQueuedAmbient() {
        if (queuedAmbient != null) {
            ambientManager.playTrack(queuedAmbient, 0, true);
            queuedAmbient = null;
        }
    }
 
    /**
     *  Stops ambient sound
     */
    void stopAmbient() {
        queuedAmbient = null;
        if (isAvailable()) {
            ambientManager.stopChannel(0);
        }
    }
 
    /**
     * To play the sound in the animations
     */
 
    void playCutsceneAmbient() {
        if (isAvailable()) {
            try {
                cutsceneAudioClip.loop();
            } catch (IllegalStateException e) {
                Log.e(TAG, "playing cutscene ambient track is failed.");
                cutsceneAmbientAvailable = false;
            }
        }
    }
 
    /**
     * Stop playing sound in the end of cutscene
     */
    void stopCutsceneAmbient() {
        if (isAvailable()) {
            try {
                cutsceneAudioClip.stop();
            } catch (IllegalStateException e) {
                Log.e(TAG, "stopping cutscene ambient track is failed.");
                cutsceneAmbientAvailable = false;
            }
        }
    }
/**checks the sound availability*/
    boolean isAvailable() {
        return soundAvailable
                && ambientAvailable
                && cutsceneAmbientAvailable;
    }
 
    /**
     * Destroy sounds when the application killed
     */
    void destroy() {
        soundManager.destroy();
        ambientManager.destroy();
        cutsceneAudioClip.destroy();
    }
 
    /**
     * The class which load all the sound files  in the start of the application and then it can we
     * use to play sounds in the application as and when required.
     * Play sounds in response of some actions performed by user.
     */
    private static class SoundPoolManager {
        /**
         * Static interface to notify the availability of the sound
         * check if scpecific sound available or not to play it as a queued sound
         */
        private static interface AvailabilityNotifier {
            void notifyAvailability();
        }
 
        private final Context context;
        private final int[] soundResources;
        private final int[] channels;
        private SoundPool soundPool;
        private final Map<String, Integer> soundIds;//hash map that will save an id of each sound that will displayed in required time
 
        /**
         * Constructor that builds the class with an appropriate parameters
         * @param context
         * @param soundResources
         * @param channelCount
         */
        SoundPoolManager(
                Context context,
                int[] soundResources,
                int channelCount) {
            this.context = context;
            this.soundResources = soundResources;
            this.channels = new int[channelCount];
            this.soundIds = new HashMap<String, Integer>();
        }
 
        @TargetApi(Build.VERSION_CODES.FROYO)//to support an appropriate API
        /**
         * Method inits and loads files to the player
         */
        void init(final AvailabilityNotifier notifier) {
            this.soundPool =
                    new SoundPool(
                            channels.length,
                            AudioManager.STREAM_MUSIC,
                            0);
            /*Set the load listener of audio files*/
            soundPool.setOnLoadCompleteListener(new OnLoadCompleteListener() {
                private int count = 0;
                private boolean success = true;
                /*when the loading files completed,onLoadComplete() will be called*/
                @Override
                public void onLoadComplete(
                        SoundPool soundPool,
                        int sampleId,
                        int status) {
                    count++;
                    success = success && (status == 0);
                    if (count == soundResources.length) {
                        if (success) {
                            notifier.notifyAvailability();
                        }
                    }
                }
            });
            /*put all sound id's into the HashMap to know which sound id to display in required time*/
            for (int res : soundResources) {
                soundIds.put(
                        context.getResources().getResourceEntryName(res),
                        Integer.valueOf(soundPool.load(context, res, 1)));
            }
        }
 
        /**
         * To destroy sounds when the application killed
         */
        void destroy() {
            if (soundPool != null) {
                soundPool.release();
                soundPool = null;
            }
 
            soundIds.clear();
            for (int i = 0; i < channels.length; i++) {
                channels[i] = 0;
            }
        }
 
        void playTrack(String track, int channel, boolean repeat) {
            if (soundPool == null) {
                return;
            }
 
            Integer id = soundIds.get(track);
            if (id == null) {
                throw new IllegalArgumentException(
                        "invalid track name. : " + track);
            }
            if (channel >= channels.length) {
                throw new IllegalArgumentException(
                        "channel is too large. : " + channel);
            }
 
            channels[channel] =
                    soundPool.play(
                            id.intValue(),
                            1,
                            1,
                            0,
                            (repeat ? -1 : 0),
                            1);
        }
 
        void stopChannel(int channel) {
            if (soundPool == null) {
                return;
            }
 
            if (channel >= channels.length) {
                throw new IllegalArgumentException(
                        "channel is too large. : " + channel);
            }
 
            int id = channels[channel];
            if (id != 0) {
                soundPool.stop(id);
                channels[channel] = 0;
            }
        }
    }
 
    /**
     * The AudioClip is a static class for playing a sound clip.
     * Multiple AudioClip items can be playing at the same time, and the resulting sound is mixed together to produce a composite.
     */
    private static class AudioClip {
 
        private final Context context;
        private MediaPlayer mPlayer;
        private boolean mPlaying = false;
        private boolean mLoop = false;
 
        AudioClip(Context context) {
            this.context = context;
        }
 
        boolean init() {
            mPlayer = MediaPlayer.create(context, CUTSCENE_RESOURCE_ID);
            if (mPlayer == null) {
                return false;
            }
            /*Register a callback to be invoked when the end of a media source has been reached during playback.
            * Creates overrided method onCompletion(MediaPlayer mp)
            * */
            mPlayer.setOnCompletionListener(new MediaPlayer.OnCompletionListener() {
                /**
                 * Called when the end of a media source is reached during playback
                 * @param mp-the MediaPlayer that reached the end of the file
                 */
                @Override
                public void onCompletion(MediaPlayer mp) {
                    mPlaying = false;
                    if (mLoop) {
                        play();
                    }
                }
            });
            return true;
        }
 
        /**
         * Starts playing this audio clip. Each time this method is called, the clip is restarted from the beginning.
         */
        void play() {
            if (mPlaying) {
                return;
            }
 
            if (mPlayer != null) {
                mPlayer.start();
                mPlaying = true;
            }
        }
 
        /**
         * Stops playing this audio clip.
         */
        void stop() {
            mLoop = false;
            if (mPlaying) {
                if (mPlayer != null) {
                    mPlayer.pause();
                    mPlayer.seekTo(0);
                }
                mPlaying = false;
            }
        }
 
        /**
         * Starts playing this audio clip in a loop.
         */
        void loop() {
            mLoop = true;
            play();
        }
 
        /**
         * Destroys playing this audio clip.
         */
        void destroy() {
            if (mPlayer != null) {
                mPlayer.release();
                mPlayer = null;
            }
        }
    }
 
}
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
18.09.2015, 19:27     Разбираю исходник игры Пакман
Посмотрите здесь:

Создание многоуровневой игры Android
Android Имидж загрузки игры
физика для игры Android
Android Flash .apk [нужен исходник] + дам на пиво)
Написание игры Android
Android Разработка игры
Написание ежедневника. Есть исходник. Помогите в нем разобраться Android
Android Как понять в какой программе создан исходник?
Игра пакман на андроид Android
Android Запись звука. MediaRecorder. разбираю пример
Apk файл в исходник Android

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
YuraAAA
1564 / 1306 / 269
Регистрация: 25.10.2009
Сообщений: 3,424
Записей в блоге: 2
18.09.2015, 19:37     Разбираю исходник игры Пакман #2
EduardSakhnovic, судя по всему, он нужен для воспроизведения звуков
Yandex
Объявления
18.09.2015, 19:37     Разбираю исходник игры Пакман
Ответ Создать тему
Опции темы

Текущее время: 00:16. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru