Spiel - Mücke (brauche Hilfe beim Tier hinzufügen)

1public void onClick(View muecke) {
2 if (muecke.getId() == R.id.pause) {
3 boolean paused = false; {
4 onPause(); {
5 return;
6 }
7 }
8 }

1@Override
2 protected void onPause() {
3 super.onPause();
4 if (Pause.getId()== R.id.pause){
5 boolean paused = true; {
6 zeitHerunterzaehlen(); // Wie soll ich dies sonst schreiben, damit die stoppen???
7 mueckenBewegen(); {
8 return;}
9 }}
10 }

1private static final long HOECHSTALTER_MS = 2000;

1private void zeitHerunterzaehlen() {
2 zeit = zeit -1;
3 float zufallszahl = zufallsgenerator.nextFloat();
4 double wahrscheinlichkeit = muecken * 1.5 / 60;
5 if(wahrscheinlichkeit > 1) {
6 eineMueckeAnzeigen();
7 if(zufallszahl < wahrscheinlichkeit-1) {
8 eineMueckeAnzeigen();
9 }
10 } else {
11 if(zufallszahl < wahrscheinlichkeit) {
12 eineMueckeAnzeigen();
13 }
14 }
15 mueckenVerschwinden();
16 bildschirmAktualisieren();
17 if(!pruefeSpielende()) {
18 if(!pruefeRundenende()) {
19 handler.postDelayed(this, 1000);
20 }
21 }
22 }

1public boolean paused = false

1@Override
2 public void onClick(View muecke) {
3 if (muecke.getId() == R.id.pause) {
4 paused = true; {
5 onPause();
6 }
7 }
8 else if(muecke.getTag(R.id.tier) == FLIEGE) {
9 punkte -= 500 - schwierigkeitsgrad*50;
10 } else {
11 gefangeneMuecken++;
12 punkte += 100 + schwierigkeitsgrad*100;
13 }
14 bildschirmAktualisieren();
15 mp.pause();
16 Animation animationTreffer = AnimationUtils.loadAnimation(this, R.anim.treffer);
17 animationTreffer.setAnimationListener(new MueckeAnimationListener(muecke));
18 muecke.startAnimation(animationTreffer);
19 muecke.setOnClickListener(null);
20 }
21
22 private class MueckeAnimationListener implements AnimationListener {
23 private View muecke;
24 public MueckeAnimationListener(View m) {
25 muecke = m;
26 }
27 @Override
28 public void onAnimationEnd(Animation arg0) {
29 handler.post(new Runnable() {
30 @Override
31 public void run() {
32 spielbereich.removeView(muecke);
33 }
34 });
35 }
36 }
37 @Override
38 public void run() {
39 mueckenBewegen();
40 frame++;
41 if(frame >= 1000/INTERVALL_MS) {
42 zeitHerunterzaehlen();
43 frame = 0;
44 }
45 if(!pruefeSpielende()) {
46 if(!pruefeRundenende()) {
47 handler.postDelayed(this, INTERVALL_MS);
48 }
49 }
50 }
51 @Override
52 protected void onDestroy() {
53 mp.release();
54 super.onDestroy();
55 }
56 @Override
57 protected void onPause() {
58 super.onPause();
59 if (Pause.getId()== R.id.pause){
60 paused = true; {
61 paused();}
62 paused = false; {
63 onResume();}
64 }
65 }
66 public boolean paused() {
67 spielLaeuft = false;
68 return paused;
69 }
70
71 @Override
72 protected void onResume() {
73 super.onResume();
74 paused = false; {
75 spielLaeuft = true;
76 }
77 return;
78 }

1package de.androidnewcomer.mueckenfang;
2
3import java.util.Date;
4import java.util.Random;
5
6import android.app.Activity;
7import android.content.Intent;
8import android.media.MediaPlayer;
9import android.os.Bundle;
10import android.os.Handler;
11import android.view.Gravity;
12import android.view.View;
13import android.view.View.OnClickListener;
14import android.view.ViewGroup;
15import android.view.ViewGroup.LayoutParams;
16import android.view.animation.Animation;
17import android.view.animation.Animation.AnimationListener;
18import android.view.animation.AnimationUtils;
19import android.widget.Button;
20import android.widget.FrameLayout;
21import android.widget.ImageView;
22import android.widget.TextView;
23
24public class GameActivity extends Activity implements OnClickListener, Runnable {
25
26 private static final long HOECHSTALTER_MS = 2000;
27 private int runde;
28 private int punkte;
29 private int muecken;
30 private int gefangeneMuecken;
31 private int zeit;
32 private float massstab;
33 private Random zufallsgenerator = new Random();
34 private ViewGroup spielbereich;
35 private Handler handler = new Handler();
36 private MediaPlayer mp;
37 private Random rnd = new Random();
38 private int schwierigkeitsgrad;
39 private static final String FLIEGE = "FLIEGE";
40 private Button pause;
41
42 @Override
43 protected void onCreate(Bundle savedInstanceState) {
44 super.onCreate(savedInstanceState);
45 setContentView(R.layout.game);
46 massstab = getResources().getDisplayMetrics().density;
47 spielbereich = (ViewGroup) findViewById(R.id.spielbereich);
48 mp = MediaPlayer.create(this, R.raw.summen);
49 schwierigkeitsgrad = getIntent().getIntExtra("schwierigkeitsgrad", 0);
50
51 pause = (Button) findViewById(R.id.schliessen);
52 pause.setOnClickListener(this);
53
54 spielStarten();
55 }
56
57 private void spielStarten() {
58 runde = 0;
59 punkte = 0;
60 starteRunde();
61 }
62
63 private void starteRunde() {
64 runde = runde +1;
65 muecken = runde *(10 + schwierigkeitsgrad *10);
66 gefangeneMuecken = 0;
67 zeit = 60;
68 bildschirmAktualisieren();
69 handler.postDelayed(this, 1000);
70 }
71
72 private void zeitHerunterzaehlen() {
73 zeit = zeit -1;
74 float zufallszahl = zufallsgenerator.nextFloat();
75 double wahrscheinlichkeit = muecken * 1.5 / 60;
76 if(wahrscheinlichkeit > 1) {
77 eineMueckeAnzeigen();
78 if(zufallszahl < wahrscheinlichkeit-1) {
79 eineMueckeAnzeigen();
80 }
81 } else {
82 if(zufallszahl < wahrscheinlichkeit) {
83 eineMueckeAnzeigen();
84 }
85 }
86 mueckenVerschwinden();
87 bildschirmAktualisieren();
88 if(!pruefeSpielende()) {
89 if(!pruefeRundenende()) {
90 handler.postDelayed(this, 1000);
91 }
92 }
93 }
94
95 private void mueckenVerschwinden() {
96 int nummer=0;
97 while(nummer < spielbereich.getChildCount()) {
98 ImageView muecke = (ImageView) spielbereich.getChildAt(nummer);
99 Date geburtsdatum = (Date) muecke.getTag(R.id.geburtsdatum);
100 long alter = (new Date()).getTime() - geburtsdatum.getTime();
101 if(alter > HOECHSTALTER_MS) {
102 spielbereich.removeView(muecke);
103 } else {
104 nummer++;
105 }
106 }
107 }
108
109 private boolean pruefeSpielende() {
110 if(zeit == 0 && gefangeneMuecken < muecken) {
111 gameOver();
112 return true;
113 }
114 return false;
115 }
116
117 private void gameOver() {
118 setResult(punkte);
119 startActivity( new Intent(this, GameOverActivity.class));
120 finish();
121 }
122
123 private boolean pruefeRundenende() {
124 if(gefangeneMuecken >= muecken) {
125 starteRunde();
126 return true;
127 }
128 return false;
129 }
130
131 @Override
132 public void onClick(View muecke) {
133 if (muecke.getId() ==R.id.pause) {
134
135 }
136 if else (muecke.getTag(R.id.tier) == FLIEGE) {
137 punkte -= 500 + schwierigkeitsgrad *100;
138 } else {
139 gefangeneMuecken++;
140 punkte += 100 + schwierigkeitsgrad*100;
141 }
142
143 bildschirmAktualisieren();
144 mp.pause();
145 Animation animationTreffer = AnimationUtils.loadAnimation(this, R.anim.treffer);
146 animationTreffer.setAnimationListener(new MueckeAnimationListener(muecke));
147 muecke.startAnimation(animationTreffer);
148 muecke.setOnClickListener(null);
149 }
150
151 private class MueckeAnimationListener implements AnimationListener {
152 private View muecke;
153 public MueckeAnimationListener(View m) {
154 muecke = m;
155 }
156 @Override
157 public void onAnimationEnd(Animation arg0) {
158 handler.post(new Runnable() {
159 @Override
160 public void run() {
161 spielbereich.removeView(muecke);
162 }
163 });
164 }
165
166 @Override
167 public void run() {
168 zeitHerunterzaehlen();
169 }
170
171 @Override
172 protected void onDestroy() {
173 mp.release();
174 super.onDestroy();
175 }
176
177 @Override
178 protected void onPause() {
179 super.onPause();
180 handler.removeCallbacks(this);
181 }
182}

1private boolean onClick1(View paused) {
2 if (paused.getId()== R.id.pause) {
3 paused();
4 return true;
5 }
6 return false;
7 }
8
9
10 @Override
11 public void onClick(View muecke) {
12 if (muecke.getTag(R.id.tier) == FLIEGE) {
13 punkte -= 500 + schwierigkeitsgrad *100;
14 } else {
15 gefangeneMuecken++;
16 punkte += 100 + schwierigkeitsgrad*100;
17 }

1private void zeitHerunterzaehlen() {
2 zeit = zeit -1;
3 float zufallszahl = zufallsgenerator.nextFloat();
4 double wahrscheinlichkeit = muecken * 1.5 / 60;
5 if(wahrscheinlichkeit > 1) {
6 eineMueckeAnzeigen();
7 if(zufallszahl < wahrscheinlichkeit-1) {
8 eineMueckeAnzeigen();
9 }
10 } else {
11 if(zufallszahl < wahrscheinlichkeit) {
12 eineMueckeAnzeigen();
13 }
14 }
15 mueckenVerschwinden();
16 bildschirmAktualisieren();
17 if(!pruefeSpielende()) {
18 if(!pruefeRundenende()) {
19 handler.postDelayed(this, 1000);
20 }
21 } if (!paused) {
22 handler.postDelayed(this, zeit);
23 }
24 }

1@Override
2 public void onClick(View muecke) {
3 if(muecke.getTag(R.id.tier) == FLIEGE) {
4 punkte -= 500 + schwierigkeitsgrad *100;
5 } else {
6 gefangeneMuecken++;
7 punkte += 100 + schwierigkeitsgrad*100;
8 }
9 if (muecke.getId()== R.id.pause) {
10 paused = true;
11 zeitHerunterzaehlen();
12 }else {
13 paused = false;
14 }
15 bildschirmAktualisieren();
16 mp.pause();
17 Animation animationTreffer = AnimationUtils.loadAnimation(this, R.anim.treffer);
18 animationTreffer.setAnimationListener(new MueckeAnimationListener(muecke));
19 muecke.startAnimation(animationTreffer);
20 muecke.setOnClickListener(null);

1public void zeitHerunterzaehlen() {
2 zeit = zeit -1;
3 float zufallszahl = zufallsgenerator.nextFloat();
4 double wahrscheinlichkeit = muecken * 1.5 / 60;
5 if(wahrscheinlichkeit > 1) {
6 eineMueckeAnzeigen();
7 if(zufallszahl < wahrscheinlichkeit-1) {
8 eineMueckeAnzeigen();
9 }
10 } else {
11 if(zufallszahl < wahrscheinlichkeit) {
12 eineMueckeAnzeigen();
13 }
14 }
15 mueckenVerschwinden();
16 bildschirmAktualisieren();
17 if(!pruefeSpielende()) {
18 if(!pruefeRundenende()) {
19 handler.postDelayed(this, 1000);
20 }
21 }
22 if (!paused) {
23 handler.postDelayed(this, 60000); // in 30sec spiel aus
24 }
25 }

1public void zeitHerunterzaehlen() {
2 if (!paused) {
3 //Mücken erstellen etc.
4 handler.postDelayed(this, zeit);
5 }
6 zeit = zeit -1;
7 float zufallszahl = zufallsgenerator.nextFloat();
8 double wahrscheinlichkeit = muecken * 1.5 / 60;
9 if(wahrscheinlichkeit > 1) {
10 eineMueckeAnzeigen();
11 if(zufallszahl < wahrscheinlichkeit-1) {
12 eineMueckeAnzeigen();
13 }
14 } else {
15 if(zufallszahl < wahrscheinlichkeit) {
16 eineMueckeAnzeigen();
17 }
18 }
19 mueckenVerschwinden();
20 bildschirmAktualisieren();
21 if(!pruefeSpielende()) {
22 if(!pruefeRundenende()) {
23 handler.postDelayed(this, 1000);
24 }
25 }
26 }

1public void zeitHerunterzaehlen() {
2 if (!paused){
3 handler.postDelayed(this, zeit);
4
5 zeit = zeit -1;
6 float zufallszahl = zufallsgenerator.nextFloat();
7 double wahrscheinlichkeit = muecken * 1.5 / 60;
8 if(wahrscheinlichkeit > 1) {
9 eineMueckeAnzeigen();
10 if(zufallszahl < wahrscheinlichkeit-1) {
11 eineMueckeAnzeigen();
12 }
13 } else {
14 if(zufallszahl < wahrscheinlichkeit) {
15 eineMueckeAnzeigen();
16 }
17 }
18 mueckenVerschwinden();
19 bildschirmAktualisieren();
20 if(!pruefeSpielende()) {
21 if(!pruefeRundenende()) {
22 handler.postDelayed(this, 1000);
23 }
24 } }
25 }

1public void onClick(View muecke) {
2 if (muecke.getTag(R.id.tier) == FLIEGE) {
3 punkte -= 500 + schwierigkeitsgrad *100;
4 } else {
5 gefangeneMuecken++;
6 punkte += 100 + schwierigkeitsgrad*100;
7 }
8 if (muecke.getId()== R.id.pause) {
9 paused = true;
10 zeitHerunterzaehlen();
11 }else {
12 paused = false;
13 }
14 bildschirmAktualisieren();
15 mp.pause();
16 Animation animationTreffer = AnimationUtils.loadAnimation(this, R.anim.treffer);
17 animationTreffer.setAnimationListener(new MueckeAnimationListener(muecke));
18 muecke.startAnimation(animationTreffer);
19 muecke.setOnClickListener(null);
20 }

1public void onClick(View muecke) {
2 if (muecke.getTag(R.id.tier) == FLIEGE) {
3 punkte -= 500 + schwierigkeitsgrad *100;
4 } else {
5 gefangeneMuecken++;
6 punkte += 100 + schwierigkeitsgrad*100;
7 }
8 if (muecke.getId()== R.id.pause) {
9 paused = true;
10 zeitHerunterzaehlen();
11 }else {
12 paused = false;
13 zeitHerunterzaehlen();
14 }

1public void onClick (View muecke) {if (muecke..... R.id.pause) {
2paused =true;
3zeitHerunterzaehlen();
4return;
5}
6
7if (muecke...Tag (R.id.tier) == FLIEGE) {
8.........} else{ .........}
9
10if (muecke.getId.... R.id.pause) {
11paused = false;
12zeitHerunterzaehlen();
13}
14}